devsecops-engine-tools 1.8.7__py3-none-any.whl → 1.8.9__py3-none-any.whl

devsecops_engine_tools/engine_core/src/domain/model/gateway/vulnerability_management_gateway.py

@@ -17,7 +17,7 @@ class VulnerabilityManagementGateway(metaclass=ABCMeta):
         "get_findings_excepted"
 
     @abstractmethod
-    def get_all_findings(
+    def get_all(
         self, service, dict_args, secret_tool, config_tool
     ):
-        "get_report"
+        "get all findings and exclusions from vulnerability management platform"

devsecops_engine_tools/engine_core/src/domain/model/report.py

@@ -4,10 +4,31 @@ from dataclasses import dataclass
 @dataclass
 class Report:
     def __init__(self, **kwargs):
-        self.id = kwargs.get("id", "")
-        self.date = kwargs.get("date", "")
+        self.id = kwargs.get("id", [])
+        self.vuln_id_from_tool = kwargs.get("vuln_id_from_tool", "")
         self.where = kwargs.get("where", "")
         self.tags = kwargs.get("tags", [])
         self.severity = kwargs.get("severity", "")
+        self.age = kwargs.get("age", "")
         self.active = kwargs.get("active", "")
         self.status = kwargs.get("status", "")
+        self.risk_status = kwargs.get("risk_status", "")
+        self.risk_score = kwargs.get("risk_score", "")
+        self.created = kwargs.get("created", "")
+        self.publish_date = kwargs.get("publish_date", "")
+        self.last_reviewed = kwargs.get("last_reviewed", "")
+        self.last_status_update = kwargs.get("last_status_update", "")
+        self.accepted_risks = kwargs.get("accepted_risks", "")
+        self.transfer_finding = kwargs.get("transfer_finding", "")
+        self.epss_score = kwargs.get("epss_score", "")
+        self.epss_percentile = kwargs.get("epss_percentile", "")
+        self.mitigated = kwargs.get("mitigated", "")
+        self.vul_description = kwargs.get("vul_description", "")
+        self.risk_accepted = kwargs.get("risk_accepted", "")
+        self.false_p = kwargs.get("false_p", "")
+        self.service = kwargs.get("service", "")
+        self.reason = kwargs.get("reason", "")
+        self.component_name = kwargs.get("component_name", "")
+        self.component_version = kwargs.get("component_version", "")
+        self.file_path = kwargs.get("file_path", "")
+        self.endpoints = kwargs.get("endpoints", "")

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

@@ -16,6 +16,9 @@ from devsecops_engine_tools.engine_risk.src.applications.runner_engine_risk impo
 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
@@ -36,29 +39,63 @@ class HandleRisk:
         self.devops_platform_gateway = devops_platform_gateway
         self.print_table_gateway = print_table_gateway
 
-    def get_finding_list(self, dict_args, secret_tool, remote_config):
+    def _get_all_from_vm(self, dict_args, secret_tool, remote_config, service):
         try:
-            findigs_list = self.vulnerability_management.get_all_findings(
-                self.devops_platform_gateway.get_variable("pipeline_name"),
+            return self.vulnerability_management.get_all(
+                service,
                 dict_args,
                 secret_tool,
                 remote_config,
             )
-            return findigs_list
         except ExceptionGettingFindings as e:
-            logger.error("Error getting finding list in handle risk: {0}".format(str(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)
 
-        findigs_list = self.get_finding_list(dict_args, secret_tool, 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
+        )
 
-        runner_engine_risk(
+        findings_list = parent_findings + findings
+
+        exclusions_list = parent_exclusions + exclusions
+
+        result = runner_engine_risk(
             dict_args,
-            findigs_list,
+            findings_list,
+            exclusions_list,
             self.devops_platform_gateway,
-            self.print_table_gateway
+            self.print_table_gateway,
+        )
+        input_core = InputCore(
+            [],
+            {},
+            "",
+            "",
+            service,
+            self.devops_platform_gateway.get_variable("stage").capitalize(),
         )
+        return result, input_core

devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/defect_dojo/defect_dojo.py

@@ -199,7 +199,11 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                 "Transferred Finding",
             )
 
-            return list(exclusions_risk_accepted) + list(exclusions_false_positive) + list(exclusions_transfer_finding)
+            return (
+                list(exclusions_risk_accepted)
+                + list(exclusions_false_positive)
+                + list(exclusions_transfer_finding)
+            )
         except Exception as ex:
             raise ExceptionFindingsExcepted(
                 "Error getting excepted findings with the following error: {0} ".format(
@@ -207,7 +211,7 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                 )
             )
 
-    def get_all_findings(self, service, dict_args, secret_tool, config_tool):
+    def get_all(self, service, dict_args, secret_tool, config_tool):
         try:
             all_findings_query_params = {
                 "limit": config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"][
@@ -225,16 +229,18 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                 all_findings_query_params,
             )
 
-            maped_list = list(
+            all_findings = list(
                 map(
-                    partial(
-                        self._create_report, date_fn=self._format_date_to_dd_format
-                    ),
+                    partial(self._create_report),
                     findings,
                 )
             )
 
-            return maped_list
+            all_exclusions = self._get_report_exclusions(
+                all_findings, self._format_date_to_dd_format
+            )
+
+            return all_findings, all_exclusions
 
         except Exception as ex:
             raise ExceptionGettingFindings(
@@ -250,6 +256,29 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
             config_tool["VULNERABILITY_MANAGER"]["DEFECT_DOJO"]["HOST_DEFECT_DOJO"],
         )
 
+    def _get_report_exclusions(self, total_findings, date_fn):
+        exclusions = []
+        for finding in total_findings:
+            if finding.risk_accepted:
+                exclusions.append(
+                    self._create_exclusion(
+                        finding, date_fn, "engine_risk", "Risk Accepted"
+                    )
+                )
+            elif finding.false_p:
+                exclusions.append(
+                    self._create_exclusion(
+                        finding, date_fn, "engine_risk", "False Positive"
+                    )
+                )
+            elif finding.risk_status == "Transfer Accepted":
+                exclusions.append(
+                    self._create_exclusion(
+                        finding, date_fn, "engine_risk", "Transferred Finding"
+                    )
+                )
+        return exclusions
+
     def _get_findings_with_exclusions(
         self, session_manager, service, max_retries, query_params, tool, date_fn, reason
     ):
@@ -293,24 +322,44 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
             last_accepted_risk = finding.accepted_risks[-1]
             create_date = date_fn(last_accepted_risk["created"])
             expired_date = date_fn(last_accepted_risk["expiration_date"])
-        
+
         return Exclusions(
             id=finding.vuln_id_from_tool,
             where=self._get_where(finding, tool),
             create_date=create_date,
             expired_date=expired_date,
+            severity=finding.severity,
             reason=reason,
         )
 
-    def _create_report(self, finding, date_fn):
+    def _create_report(self, finding):
         return Report(
-            id=finding.vuln_id_from_tool,
-            date=date_fn(finding.date),
+            id=finding.vulnerability_ids,
+            vuln_id_from_tool=finding.vuln_id_from_tool,
             status=finding.display_status,
-            where=self._get_where_report(finding),
+            component_name=finding.component_name,
+            component_version=finding.component_version,
+            file_path=finding.file_path,
+            endpoints=finding.endpoints,
+            where=self._get_where(finding, "engine_risk"),
             tags=finding.tags,
             severity=finding.severity,
+            age=finding.age,
             active=finding.active,
+            risk_status=finding.risk_status,
+            created=finding.created,
+            publish_date=finding.publish_date,
+            last_reviewed=finding.last_reviewed,
+            last_status_update=finding.last_status_update,
+            accepted_risks=finding.accepted_risks,
+            transfer_finding=finding.transfer_finding,
+            epss_score=finding.epss_score,
+            epss_percentile=finding.epss_percentile,
+            mitigated=finding.is_mitigated,
+            vul_description=finding.description,
+            risk_accepted=finding.risk_accepted,
+            false_p=finding.false_p,
+            service=finding.service,
         )
 
     def _format_date_to_dd_format(self, date_string):
@@ -320,14 +369,13 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
             else None
         )
 
-    def _get_where_report(self, finding):
-        for tag in finding.tags:
-            return self._get_where(finding, tag)
-
     def _get_where(self, finding, tool):
         if tool in ["engine_container", "engine_dependencies"]:
             return finding.component_name + ":" + finding.component_version
         elif tool == "engine_dast":
             return finding.endpoints
+        elif tool == "engine_risk":
+            for tag in finding.tags:
+                return self._get_where(finding, tag)
         else:
             return finding.file_path

devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/printer_pretty_table/printer_pretty_table.py

@@ -63,22 +63,23 @@ class PrinterPrettyTable(PrinterTableGateway):
             print(sorted_table)
 
     def print_table_report(self, report_list: "list[Report]"):
-        headers = ["Severity", "ID", "Tag", "Where"]
+        headers = ["Risk Score", "Severity", "ID", "Tags", "Where", "Service"]
         table = PrettyTable(headers)
         for report in report_list:
             row_data = [
+                report.risk_score,
                 report.severity.lower(),
-                report.id,
+                report.vuln_id_from_tool if report.vuln_id_from_tool else report.id,
                 report.tags,
                 report.where,
+                report.service
             ]
             table.add_row(row_data)
 
-        severity_order = {"critical": 0, "high": 1, "medium": 2, "low": 3}
         sorted_table = PrettyTable()
         sorted_table.field_names = table.field_names
         sorted_table.add_rows(
-            sorted(table._rows, key=lambda row: severity_order[row[0]])
+            sorted(table._rows, key=lambda row: row[0], reverse=True)
         )
 
         for column in table.field_names:

devsecops_engine_tools/engine_core/src/infrastructure/entry_points/entry_point_core.py

@@ -30,12 +30,13 @@ def init_engine_core(
 
     if config_tool[args["tool"].upper()]["ENABLED"] == "true":
         if args["tool"] == "engine_risk":
-            HandleRisk(
+            results, input_core = HandleRisk(
                 vulnerability_management_gateway,
                 secrets_manager_gateway,
                 devops_platform_gateway,
                 print_table_gateway,
             ).process(args, config_tool)
+
         else:
             findings_list, input_core = HandleScan(
                 vulnerability_management_gateway,
@@ -43,15 +44,15 @@ def init_engine_core(
                 devops_platform_gateway,
             ).process(args, config_tool)
 
-            scan_result = BreakBuild(devops_platform_gateway, print_table_gateway).process(
+            results = BreakBuild(devops_platform_gateway, print_table_gateway).process(
                 findings_list,
                 input_core,
                 args
             )
-            if args["send_metrics"] == "true":
-                MetricsManager(devops_platform_gateway, metrics_manager_gateway).process(
-                    config_tool, input_core, args, scan_result
-                )
+        if args["send_metrics"] == "true":
+            MetricsManager(devops_platform_gateway, metrics_manager_gateway).process(
+                config_tool, input_core, args, results
+            )
     else:
         print(
             devops_platform_gateway.message(

devsecops_engine_tools/engine_core/src/infrastructure/helpers/util.py

@@ -11,5 +11,5 @@ def define_env(variable_env, branch):
     return (
         "pdn"
         if branch in ["trunk", "master"]
-        else "qa" if branch in "release" else "dev"
+        else "qa" if branch=="release" else "dev"
     )

devsecops_engine_tools/engine_risk/src/applications/runner_engine_risk.py

@@ -1,3 +1,6 @@
+from devsecops_engine_tools.engine_risk.src.infrastructure.driven_adapters.first_csv.first_epss_csv import (
+    FirstCsv,
+)
 from devsecops_engine_tools.engine_risk.src.infrastructure.entry_points.entry_point_risk import (
     init_engine_risk,
 )
@@ -10,11 +13,15 @@ logger = MyLogger.__call__(**settings.SETTING_LOGGER).get_logger()
 
 
 def runner_engine_risk(
-    dict_args, findings, devops_platform_gateway, print_table_gateway
+    dict_args, findings, vm_exclusions, devops_platform_gateway, print_table_gateway
 ):
-    init_engine_risk(
+    add_epss_gateway = FirstCsv()
+
+    return init_engine_risk(
+        add_epss_gateway,
         devops_platform_gateway,
         print_table_gateway,
         dict_args,
         findings,
+        vm_exclusions,
     )

devsecops_engine_tools/engine_risk/src/domain/model/gateways/add_epss_gateway.py

@@ -0,0 +1,7 @@
+from abc import ABCMeta, abstractmethod
+
+
+class AddEpssGateway(metaclass=ABCMeta):
+    @abstractmethod
+    def add_epss_data(self, findings) -> list:
+        "run add epss tool"

devsecops_engine_tools/engine_risk/src/domain/usecases/add_data.py

@@ -0,0 +1,16 @@
+from devsecops_engine_tools.engine_risk.src.domain.model.gateways.add_epss_gateway import (
+    AddEpssGateway,
+)
+
+
+class AddData:
+    def __init__(
+        self,
+        add_epss_gateway: AddEpssGateway,
+        findings,
+    ):
+        self.add_epss_gateway = add_epss_gateway
+        self.findings = findings
+
+    def process(self):
+        return self.add_epss_gateway.add_epss_data(self.findings)

devsecops_engine_tools/engine_risk/src/domain/usecases/break_build.py

@@ -7,6 +7,12 @@ from devsecops_engine_tools.engine_core.src.domain.model.gateway.printer_table_g
 from devsecops_engine_tools.engine_core.src.domain.model.report import (
     Report,
 )
+from devsecops_engine_tools.engine_core.src.domain.model.exclusions import (
+    Exclusions,
+)
+
+from collections import Counter
+import copy
 
 
 class BreakBuild:
@@ -14,23 +20,281 @@ class BreakBuild:
         self,
         devops_platform_gateway: DevopsPlatformGateway,
         printer_table_gateway: PrinterTableGateway,
+        remote_config: any,
+        exclusions: "list[Exclusions]",
+        vm_exclusions: "list[Exclusions]",
+        report_list: "list[Report]",
+        all_report: "list[Report]",
     ):
         self.devops_platform_gateway = devops_platform_gateway
         self.printer_table_gateway = printer_table_gateway
+        self.remote_config = remote_config
+        self.exclusions = exclusions
+        self.vm_exclusions = vm_exclusions
+        self.report_list = report_list
+        self.all_report = all_report
+        self.break_build = False
+        self.warning_build = False
+        self.report_breaker = []
+        self.remediation_rate = 0
+        self.blacklisted = 0
+        self.max_risk_score = 0
+        self.status = "succeeded"
+        self.scan_result = {
+            "findings_excluded": [],
+            "vulnerabilities": {},
+            "compliances": {},
+            "risk": {},
+        }
+
+    def process(self):
+        self._remediation_rate_control(self.all_report)
+        new_report_list, applied_exclusions = self._apply_exclusions(self.report_list)
+        if self.break_build:
+            self.report_breaker.extend(copy.deepcopy(new_report_list))
+        self._tag_blacklist_control(new_report_list)
+        self._risk_score_control(new_report_list)
+        all_exclusions = list(self.vm_exclusions) + list(applied_exclusions)
+        self._print_exclusions(self._map_applied_exclusion(all_exclusions))
+
+        self.max_risk_score = (
+            max(report.risk_score for report in new_report_list)
+            if new_report_list
+            else 0
+        )
+
+        self._breaker()
+
+        self.scan_result["findings_excluded"] = list(
+            map(
+                lambda item: {
+                    "severity": item.severity,
+                    "id": item.id,
+                    "category": item.reason,
+                },
+                all_exclusions,
+            )
+        )
 
-    def process(self, report_list: "list[Report]"):
-        devops_platform_gateway = self.devops_platform_gateway
-        printer_table_gateway = self.printer_table_gateway
-        if len(report_list):
+        self.scan_result["risk"] = {
+            "risk_control": {
+                "remediation_rate": self.remediation_rate,
+                "blacklisted": self.blacklisted,
+                "max_risk_score": self.max_risk_score,
+            },
+            "status": self.status,
+            "found": list(
+                map(
+                    lambda item: {
+                        "id": (
+                            item.vuln_id_from_tool
+                            if item.vuln_id_from_tool
+                            else item.id
+                        ),
+                        "severity": item.severity,
+                        "risk_score": item.risk_score,
+                        "reason": item.reason,
+                    },
+                    self.report_breaker,
+                )
+            ),
+        }
+
+        print(
+            self.devops_platform_gateway.message(
+                "info",
+                self.remote_config["MESSAGE_INFO"],
+            )
+        )
+
+        return self.scan_result
+
+    def _breaker(self):
+        if self.break_build:
+            print(self.devops_platform_gateway.result_pipeline("failed"))
+            self.status = "failed"
+        else:
+            print(self.devops_platform_gateway.result_pipeline("succeeded"))
+
+    def _remediation_rate_control(self, all_report: "list[Report]"):
+        remote_config = self.remote_config
+        remediation_rate_value = self._get_percentage(
+            (sum(1 for report in all_report if report.mitigated)) / len(all_report)
+        )
+        risk_threshold = remote_config["THRESHOLD"]["REMEDIATION_RATE"]
+        self.remediation_rate = remediation_rate_value
+
+        if remediation_rate_value >= (risk_threshold + 5):
+            print(
+                self.devops_platform_gateway.message(
+                    "succeeded",
+                    f"Remediation Rate {remediation_rate_value}% is greater than {risk_threshold}%",
+                )
+            )
+        elif remediation_rate_value >= risk_threshold:
+            print(
+                self.devops_platform_gateway.message(
+                    "warning",
+                    f"Remediation Rate {remediation_rate_value}% is close to {risk_threshold}%",
+                )
+            )
+            self.warning_build = True
+        else:
             print(
-                "Below are all vulnerabilities from Vulnerability Management Platform"
+                self.devops_platform_gateway.message(
+                    "error",
+                    f"Remediation Rate {remediation_rate_value}% is less than {risk_threshold}%",
+                )
             )
-            printer_table_gateway.print_table_report(
+            self.break_build = True
+
+    def _get_percentage(self, decimal):
+        return round(decimal * 100, 3)
+
+    def _get_applied_exclusion(self, report: Report):
+        for exclusion in self.exclusions:
+            if exclusion.id and (report.id == exclusion.id):
+                return exclusion
+            elif exclusion.id and (report.vuln_id_from_tool == exclusion.id):
+                return exclusion
+        return None
+
+    def _map_applied_exclusion(self, exclusions: "list[Exclusions]"):
+        return [
+            {
+                "severity": exclusion.severity,
+                "id": exclusion.id,
+                "where": exclusion.where,
+                "create_date": exclusion.create_date,
+                "expired_date": exclusion.expired_date,
+                "reason": exclusion.reason,
+            }
+            for exclusion in exclusions
+        ]
+
+    def _apply_exclusions(self, report_list: "list[Report]"):
+        new_report_list = []
+        applied_exclusions = []
+        exclusions_ids = {exclusion.id for exclusion in self.exclusions if exclusion.id}
+
+        for report in report_list:
+            if report.vuln_id_from_tool and (
+                report.vuln_id_from_tool in exclusions_ids
+            ):
+                applied_exclusions.append(self._get_applied_exclusion(report))
+            elif report.id and (report.id in exclusions_ids):
+                applied_exclusions.append(self._get_applied_exclusion(report))
+            else:
+                report.reason = "Remediation Rate"
+                new_report_list.append(report)
+
+        return new_report_list, applied_exclusions
+
+    def _tag_blacklist_control(self, report_list: "list[Report]"):
+        remote_config = self.remote_config
+        if report_list:
+            tag_blacklist = set(remote_config["THRESHOLD"]["TAG_BLACKLIST"])
+            tag_age_threshold = remote_config["THRESHOLD"]["TAG_MAX_AGE"]
+
+            filtered_reports_above_threshold = [
+                (report, tag)
+                for report in report_list
+                for tag in report.tags
+                if tag in tag_blacklist and report.age >= tag_age_threshold
+            ]
+
+            filtered_reports_below_threshold = [
+                (report, tag)
+                for report in report_list
+                for tag in report.tags
+                if tag in tag_blacklist and report.age < tag_age_threshold
+            ]
+
+            for report, tag in filtered_reports_above_threshold:
+                report.reason = "Blacklisted"
+                print(
+                    self.devops_platform_gateway.message(
+                        "error",
+                        f"Report {report.vuln_id_from_tool if report.vuln_id_from_tool else report.id} with tag {tag} is blacklisted and age {report.age} is above threshold {tag_age_threshold}",
+                    )
+                )
+
+            for report, tag in filtered_reports_below_threshold:
+                print(
+                    self.devops_platform_gateway.message(
+                        "warning",
+                        f"Report {report.vuln_id_from_tool if report.vuln_id_from_tool else report.id} with tag {tag} is blacklisted but age {report.age} is below threshold {tag_age_threshold}",
+                    )
+                )
+
+            if filtered_reports_above_threshold:
+                self.break_build = True
+                self.blacklisted = len(filtered_reports_above_threshold)
+                self.report_breaker.extend(
+                    copy.deepcopy(
+                        [report for report, _ in filtered_reports_above_threshold]
+                    )
+                )
+
+    def _risk_score_control(self, report_list: "list[Report]"):
+        remote_config = self.remote_config
+        risk_score_threshold = remote_config["THRESHOLD"]["RISK_SCORE"]
+        break_build = False
+        if report_list:
+            for report in report_list:
+                report.risk_score = round(
+                    remote_config["WEIGHTS"]["severity"].get(report.severity.lower(), 0)
+                    + remote_config["WEIGHTS"]["epss_score"] * report.epss_score
+                    + remote_config["WEIGHTS"]["age"] * report.age
+                    + sum(
+                        remote_config["WEIGHTS"]["tags"].get(tag, 0)
+                        for tag in report.tags
+                    ),
+                    4,
+                )
+                if report.risk_score >= risk_score_threshold:
+                    break_build = True
+                    report.reason = "Risk Score"
+                    self.report_breaker.append(copy.deepcopy(report))
+            print(
+                "Below are open vulnerabilities from Vulnerability Management Platform"
+            )
+            self.printer_table_gateway.print_table_report(
                 report_list,
             )
+            if break_build:
+                self.break_build = True
+                print(
+                    self.devops_platform_gateway.message(
+                        "error",
+                        f"There are findings with risk score greater than {risk_score_threshold}",
+                    )
+                )
+            else:
+                print(
+                    self.devops_platform_gateway.message(
+                        "succeeded",
+                        f"There are no findings with risk score greater than {risk_score_threshold}",
+                    )
+                )
+            print(f"Findings count: {len(report_list)}")
+
         else:
             print(
-                devops_platform_gateway.message(
+                self.devops_platform_gateway.message(
                     "succeeded", "There are no vulnerabilities"
                 )
             )
+
+    def _print_exclusions(self, applied_exclusions: "list[Exclusions]"):
+        if applied_exclusions:
+            print(
+                self.devops_platform_gateway.message(
+                    "warning", "Bellow are all findings that were excepted"
+                )
+            )
+            self.printer_table_gateway.print_table_exclusions(applied_exclusions)
+            for reason, total in Counter(
+                map(lambda x: x["reason"], applied_exclusions)
+            ).items():
+                print("{0} findings count: {1}".format(reason, total))

devsecops_engine_tools/engine_risk/src/domain/usecases/get_exclusions.py

@@ -0,0 +1,69 @@
+from devsecops_engine_tools.engine_core.src.domain.model.exclusions import (
+    Exclusions,
+)
+
+
+class GetExclusions:
+    def __init__(
+        self,
+        devops_platform_gateway,
+        dict_args,
+        findings,
+        risk_config,
+        risk_exclusions,
+        pipeline_name,
+    ):
+        self.devops_platform_gateway = devops_platform_gateway
+        self.dict_args = dict_args
+        self.findings = findings
+        self.risk_config = risk_config
+        self.risk_exclusions = risk_exclusions
+        self.pipeline_name = pipeline_name
+
+    def process(self):
+        core_config = self.devops_platform_gateway.get_remote_config(
+            self.dict_args["remote_config_repo"], "engine_core/ConfigTool.json"
+        )
+        unique_tags = self._get_unique_tags()
+        exclusions = []
+        exclusions.extend(self._get_risk_exclusions())
+        for key in self.risk_config["EXCLUSIONS_PATHS"].keys():
+            if key in unique_tags:
+                exclusions.extend(
+                    self._get_exclusions_by_practice(
+                        core_config, key, self.risk_config["EXCLUSIONS_PATHS"][key]
+                    )
+                )
+
+        return exclusions
+
+    def _get_risk_exclusions(self):
+        return self._get_exclusions(self.risk_exclusions, "RISK")
+
+    def _get_exclusions_by_practice(self, core_config, practice, path):
+        exclusions_config = self.devops_platform_gateway.get_remote_config(
+            self.dict_args["remote_config_repo"], path
+        )
+        tool = core_config[practice.upper()]["TOOL"]
+        return self._get_exclusions(exclusions_config, tool)
+
+    def _get_exclusions(self, config, key):
+        exclusions = []
+        for scope in ["All", self.pipeline_name]:
+            if config.get(scope, None) and config[scope].get(key, None):
+                exclusions.extend(
+                    [
+                        Exclusions(
+                            **exclusion,
+                        )
+                        for exclusion in config[scope][key]
+                    ]
+                )
+        return exclusions
+
+    def _get_unique_tags(self):
+        unique_tags = set()
+        for finding in self.findings:
+            tags = finding.tags
+            unique_tags.update(tags)
+        return list(unique_tags)

devsecops_engine_tools/engine_risk/src/domain/usecases/handle_filters.py

@@ -1,18 +1,24 @@
 class HandleFilters:
-    def __init__(
-        self,
-        remote_config,
-    ):
-        self.remote_config = remote_config
-
     def filter(self, findings):
-        tag_list = self.remote_config["TAG_FILTER"]
-        severity_list = ["critical", "high", "medium", "low"]
+        active_findings = self._get_active_findings(findings)
+        self._get_priority_vulnerability(active_findings)
+        return active_findings
+
+    def _get_active_findings(self, findings):
         return list(
             filter(
-                lambda finding: finding.active
-                and any(tag in finding.tags for tag in tag_list)
-                and (finding.severity.lower() in severity_list),
+                lambda finding: finding.active,
                 findings,
             )
         )
+
+    def _get_priority_vulnerability(self, findings):
+        for finding in findings:
+            found_cve = False
+            for vul in finding.id:
+                if vul["vulnerability_id"].startswith("CVE"):
+                    finding.id = vul["vulnerability_id"]
+                    found_cve = True
+                    break
+            if not found_cve and finding.id:
+                finding.id = finding.id[0]["vulnerability_id"]

devsecops_engine_tools/engine_risk/src/infrastructure/driven_adapters/first_csv/first_epss_csv.py

@@ -0,0 +1,59 @@
+from devsecops_engine_tools.engine_risk.src.domain.model.gateways.add_epss_gateway import (
+    AddEpssGateway,
+)
+
+import requests
+import datetime
+import io
+import gzip
+import csv
+
+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 FirstCsv(AddEpssGateway):
+    def download_epss_data(self):
+        base_url = "https://epss.cyentia.com/epss_scores-{}.csv.gz"
+        date = datetime.datetime.now()
+        attempts = 0
+        while attempts < 2:
+            formatted_date = date.strftime("%Y-%m-%d")
+            url = base_url.format(formatted_date)
+            response = requests.get(url)
+            if response.status_code == 200:
+                with gzip.open(io.BytesIO(response.content), "rt") as f:
+                    data = f.read()
+                logger.info(f"EPSS data downloaded for date: {formatted_date}")
+                return data
+            else:
+                date -= datetime.timedelta(days=1)
+                attempts += 1
+        print("Could not find EPSS data from de last 2 days. Skipping add EPS data...")
+        logger.error(
+            "Could not find EPSS data from de last 2 days. Skipping add EPS data..."
+        )
+        return None
+
+    def get_epss_dict(self, epss_data):
+        epss_dict = {}
+        csv_reader = csv.reader(io.StringIO(epss_data))
+        for row in csv_reader:
+            if len(row) >= 2:
+                epss_dict[row[0]] = row[1]
+        return epss_dict
+
+    def add_epss_data(self, findings):
+        needs_epss_update = any(
+            finding.id[:3] == "CVE" and finding.epss_score == 0 for finding in findings
+        )
+        if needs_epss_update:
+            epss_data = self.download_epss_data()
+            if epss_data:
+                epss_dict = self.get_epss_dict(epss_data)
+                for finding in findings:
+                    if finding.id[:3] == "CVE" and finding.epss_score == 0:
+                        finding.epss_score = float(epss_dict.get(finding.id, 0))
+        return findings

devsecops_engine_tools/engine_risk/src/infrastructure/entry_points/entry_point_risk.py

@@ -4,6 +4,15 @@ from devsecops_engine_tools.engine_risk.src.domain.usecases.handle_filters impor
 from devsecops_engine_tools.engine_risk.src.domain.usecases.break_build import (
     BreakBuild,
 )
+from devsecops_engine_tools.engine_risk.src.domain.usecases.add_data import (
+    AddData,
+)
+from devsecops_engine_tools.engine_risk.src.domain.usecases.get_exclusions import (
+    GetExclusions,
+)
+
+
+import re
 
 from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
 from devsecops_engine_tools.engine_utilities import settings
@@ -11,21 +20,108 @@ from devsecops_engine_tools.engine_utilities import settings
 logger = MyLogger.__call__(**settings.SETTING_LOGGER).get_logger()
 
 
-def init_engine_risk(devops_platform_gateway, print_table_gateway, dict_args, findings):
+def init_engine_risk(
+    add_epss_gateway,
+    devops_platform_gateway,
+    print_table_gateway,
+    dict_args,
+    findings,
+    vm_exclusions,
+):
     remote_config = devops_platform_gateway.get_remote_config(
         dict_args["remote_config_repo"], "engine_risk/ConfigTool.json"
     )
-    findings_filtered = []
-    if len(findings):
-        handle_filters = HandleFilters(
-            remote_config,
-        )
-        findings_filtered = handle_filters.filter(findings)
-
-        BreakBuild(devops_platform_gateway, print_table_gateway).process(
-            findings_filtered,
-        )
-
-    else:
-        print("No Findings found in Vulnerability Management Platform")
-        logger.info("No Findings found in Vulnerability Management Platform")
+    risk_exclusions = devops_platform_gateway.get_remote_config(
+        dict_args["remote_config_repo"], "engine_risk/Exclusions.json"
+    )
+    pipeline_name = devops_platform_gateway.get_variable("pipeline_name")
+    if should_skip_analysis(remote_config, pipeline_name, risk_exclusions):
+        print("Tool skipped by DevSecOps Policy.")
+        logger.info("Tool skipped by DevSecOps Policy.")
+        return
+
+    return process_findings(
+        findings,
+        vm_exclusions,
+        dict_args,
+        pipeline_name,
+        risk_exclusions,
+        remote_config,
+        add_epss_gateway,
+        devops_platform_gateway,
+        print_table_gateway,
+    )
+
+
+def should_skip_analysis(remote_config, pipeline_name, exclusions):
+    ignore_pattern = remote_config["IGNORE_ANALYSIS_PATTERN"]
+    return re.match(ignore_pattern, pipeline_name, re.IGNORECASE) or (
+        pipeline_name in exclusions and exclusions[pipeline_name].get("SKIP_TOOL", 0)
+    )
+
+
+def process_findings(
+    findings,
+    vm_exclusions,
+    dict_args,
+    pipeline_name,
+    risk_exclusions,
+    remote_config,
+    add_epss_gateway,
+    devops_platform_gateway,
+    print_table_gateway,
+):
+    if not findings:
+        print("No findings found in Vulnerability Management Platform")
+        logger.info("No findings found in Vulnerability Management Platform")
+        return
+
+    handle_filters = HandleFilters()
+
+    return process_active_findings(
+        handle_filters.filter(findings),
+        findings,
+        vm_exclusions,
+        devops_platform_gateway,
+        dict_args,
+        remote_config,
+        risk_exclusions,
+        pipeline_name,
+        add_epss_gateway,
+        print_table_gateway,
+    )
+
+
+def process_active_findings(
+    active_findings,
+    total_findings,
+    vm_exclusions,
+    devops_platform_gateway,
+    dict_args,
+    remote_config,
+    risk_exclusions,
+    pipeline_name,
+    add_epss_gateway,
+    print_table_gateway,
+):
+    data_added = AddData(add_epss_gateway, active_findings).process()
+    get_exclusions = GetExclusions(
+        devops_platform_gateway,
+        dict_args,
+        data_added,
+        remote_config,
+        risk_exclusions,
+        pipeline_name,
+    )
+    exclusions = get_exclusions.process()
+    break_build = BreakBuild(
+        devops_platform_gateway,
+        print_table_gateway,
+        remote_config,
+        exclusions,
+        vm_exclusions,
+        data_added,
+        total_findings,
+    )
+
+    return break_build.process()

devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/driven_adapters/xray_tool/xray_manager_scan.py

@@ -204,14 +204,26 @@ class XrayScan(ToolGateway):
         result = subprocess.run(
             command, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
         )
-        if result.stdout:
-            scan_result = json.loads(result.stdout)
-            file_result = os.path.join(os.getcwd(), "scan_result.json")
-            with open(file_result, "w") as file:
-                json.dump(scan_result, file, indent=4)
+        if result.stdout or all(
+            word in result.stderr
+            for word in ["Technology", "WorkingDirectory", "Descriptors"]
+        ):
+            if result.stdout:
+                scan_result = json.loads(result.stdout)
+            else:
+                scan_result = {}
+                if any(
+                    word in result.stderr
+                    for word in ["What went wrong", "Caused by"]
+                ):
+                    logger.error(f"Error executing Xray scan: {result.stderr}")
+                    return None
             if result.stdout == "null\n":
                 logger.warning(f"Xray scan returned null: {result.stderr}")
                 return None
+            file_result = os.path.join(os.getcwd(), "scan_result.json")
+            with open(file_result, "w") as file:
+                json.dump(scan_result, file, indent=4)
             return file_result
         else:
             logger.error(f"Error executing Xray scan: {result.stderr}")

devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/finding.py

@@ -31,6 +31,8 @@ class Finding(FromDictMixin):
     date: str = ""
     sla_start_date = None
     cwe: int = 0
+    epss_score: int = 0
+    epss_percentile: int = 0
     cvssv3 = None
     cvssv3_score = None
     url: str = ""
@@ -66,6 +68,7 @@ class Finding(FromDictMixin):
     static_finding: bool = None
     dynamic_finding: bool = None
     created: str = ""
+    service: str = ""
     scanner_confidence = None
     unique_id_from_tool: str = ""
     vuln_id_from_tool: str = ""
@@ -75,7 +78,6 @@ class Finding(FromDictMixin):
     sast_source_file_path = None
     nb_occurences = None
     publish_date = None
-    service = None
     planned_remediation_date = None
     planned_remediation_version = None
     effort_for_fixing = None

devsecops_engine_tools/engine_utilities/defect_dojo/domain/request_objects/finding.py

@@ -7,6 +7,8 @@ class FindingRequest:
     component_name: str = ""
     component_version: str = ""
     created: str = ""
+    epss_score: float = 0.0
+    epss_percentile: float = 0.0
     cvssv3: str = ""
     cvssv3_score: float = 0.0
     cwe = None

devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/finding.py

@@ -6,6 +6,8 @@ class FindingSerializer(Schema):
     component_name = fields.Str(requeride=False)
     component_version = fields.Str(requeride=False)
     created = fields.Str(requeride=False)
+    epss_score: fields.Int(requeride=False)
+    epss_percentile: fields.Int(requeride=False)
     cvssv3 = fields.Str(requeride=False)
     cvssv3_score = fields.Int(requeride=False)
     cwe = fields.List(fields.Int, requeride=False)

devsecops_engine_tools/version.py

@@ -1 +1 @@
-version = '1.8.7'
+version = '1.8.9'

{devsecops_engine_tools-1.8.7.dist-info → devsecops_engine_tools-1.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devsecops-engine-tools
-Version: 1.8.7
+Version: 1.8.9
 Summary: Tool for DevSecOps strategy
 Home-page: https://github.com/bancolombia/devsecops-engine-tools
 Author: Bancolombia DevSecOps Team
@@ -67,7 +67,7 @@ pip3 install devsecops-engine-tools
 ### Scan running - flags (CLI)
 
 ```bash
-devsecops-engine-tools --platform_devops ["local","azure","github"] --remote_config_repo ["remote_config_repo"] --tool ["engine_iac", "engine_dast", "engine_secret", "engine_dependencies", "engine_container"] --folder_path ["Folder path scan engine_iac"] --platform ["k8s","cloudformation","docker", "openapi"] --use_secrets_manager ["false", "true"] --use_vulnerability_management ["false", "true"] --send_metrics ["false", "true"] --token_cmdb ["token_cmdb"] --token_vulnerability_management ["token_vulnerability_management"] --token_engine_container ["token_engine_container"] --token_engine_dependencies ["token_engine_dependencies"] --token_external_checks ["token_external_checks"] --xray_mode ["scan", "audit"] --image_to_scan ["image_to_scan"]
+devsecops-engine-tools --platform_devops ["local","azure","github"] --remote_config_repo ["remote_config_repo"] --tool ["engine_iac", "engine_dast", "engine_secret", "engine_dependencies", "engine_container", "engine_risk"] --folder_path ["Folder path scan engine_iac"] --platform ["k8s","cloudformation","docker", "openapi"] --use_secrets_manager ["false", "true"] --use_vulnerability_management ["false", "true"] --send_metrics ["false", "true"] --token_cmdb ["token_cmdb"] --token_vulnerability_management ["token_vulnerability_management"] --token_engine_container ["token_engine_container"] --token_engine_dependencies ["token_engine_dependencies"] --token_external_checks ["token_external_checks"] --xray_mode ["scan", "audit"] --image_to_scan ["image_to_scan"]
 ```
 
 ### Structure Remote Config
@@ -76,6 +76,9 @@ devsecops-engine-tools --platform_devops ["local","azure","github"] --remote_con
 📦Remote_Config
    ┣ 📂engine_core
    ┃ ┗ 📜ConfigTool.json
+   ┣ 📂engine_risk
+   ┃ ┗ 📜ConfigTool.json
+   ┃ ┗ 📜Exclusions.json
    ┣ 📂engine_sast
    ┃ ┗ 📂engine_iac
    ┃   ┗ 📜ConfigTool.json
@@ -99,6 +102,11 @@ devsecops-engine-tools --platform_devops ["local","azure","github"] --remote_con
     <th>Module</th>
     <th>Tool</th>
     <th>Type</th>
+  </tr>
+    <tr>
+    <td>ENGINE_RISK</td>
+    <td><a href="https://defectdojo.com/">DEFECTDOJO</a></td>
+    <td>Free</td>
   </tr>
   <tr>
     <td rowspan="3">ENGINE_IAC</td>

{devsecops_engine_tools-1.8.7.dist-info → devsecops_engine_tools-1.8.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
 devsecops_engine_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/version.py,sha256=CSY3U1mG4ZdGkeFALSRBoT3T-otyCaGlpwqlMkcKaLc,18
+devsecops_engine_tools/version.py,sha256=mG55fPFXaVtS3iXQqmRMOEqiEwf4trMhP86SS7-Dino,17
 devsecops_engine_tools/engine_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_core/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_core/src/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -14,7 +14,7 @@ devsecops_engine_tools/engine_core/src/domain/model/finding.py,sha256=MntDksQuPt
 devsecops_engine_tools/engine_core/src/domain/model/input_core.py,sha256=hc1WMzCwsGxnrlvvk84S5iNYJRDQWbaQP9MwR3N7tVM,422
 devsecops_engine_tools/engine_core/src/domain/model/level_compliance.py,sha256=ntn_UWqHc6sT5g_LozBdjdewTQxFsp7Kt8M0xqw-k_o,98
 devsecops_engine_tools/engine_core/src/domain/model/level_vulnerability.py,sha256=0sySEnFNkS2Y8uF5GUVAYehXw-i2OglUClkVobnSTPc,257
-devsecops_engine_tools/engine_core/src/domain/model/report.py,sha256=eJ4r39OBgB-leNImTVV2fHuublFnpmCMHcvKWvL-hxs,410
+devsecops_engine_tools/engine_core/src/domain/model/report.py,sha256=SGo9bxNGVO5ymjjuFlG3Tz1X9uh2JawNaQYyHHN_NL8,1640
 devsecops_engine_tools/engine_core/src/domain/model/threshold.py,sha256=AQu4NnYBvbUbzW_IkuCVF0_i535O4LeE3ZvBIZ7s9ZM,445
 devsecops_engine_tools/engine_core/src/domain/model/vulnerability_management.py,sha256=5RcMHpeqznrTOpkjLuqekA_Bqf2Qr-w6OZ5Eoi3b-bs,465
 devsecops_engine_tools/engine_core/src/domain/model/gateway/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,10 +22,10 @@ devsecops_engine_tools/engine_core/src/domain/model/gateway/devops_platform_gate
 devsecops_engine_tools/engine_core/src/domain/model/gateway/metrics_manager_gateway.py,sha256=u_ivbmCyymw0Je7gRFg0uD9iDmZfTbteH5UwcgP0JAs,191
 devsecops_engine_tools/engine_core/src/domain/model/gateway/printer_table_gateway.py,sha256=ROBsh7Lyu62a5RqZ4KgGQcwrBzbHRwxAJ9Rj3LoupQc,602
 devsecops_engine_tools/engine_core/src/domain/model/gateway/secrets_manager_gateway.py,sha256=CTwUIvUWF0NSSzdCqASUFst6KUysW53NV9eatjLGdl8,170
-devsecops_engine_tools/engine_core/src/domain/model/gateway/vulnerability_management_gateway.py,sha256=sn9bEDfaNtRmHHtn49eSVg_JO7Zr2OVyj350KzyGiXo,667
+devsecops_engine_tools/engine_core/src/domain/model/gateway/vulnerability_management_gateway.py,sha256=r3b9zKi0XwKfWTIF7E8Qc6ChbrCUSjh-u-0mKBjxTLA,718
 devsecops_engine_tools/engine_core/src/domain/usecases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_core/src/domain/usecases/break_build.py,sha256=FCe7Yw42eK0u71sLivQvAF-bMwZqj4aGFdBTjy7LsVI,15955
-devsecops_engine_tools/engine_core/src/domain/usecases/handle_risk.py,sha256=EBLEzm-p_lEeB7T8iarn2Fc4_6hY0XAIT1AJATd2JUM,2473
+devsecops_engine_tools/engine_core/src/domain/usecases/handle_risk.py,sha256=aJ0LuJCuQhp_ZT9Ctx5kdc4jIhmMoKemAZm9POp--Ig,3688
 devsecops_engine_tools/engine_core/src/domain/usecases/handle_scan.py,sha256=ee9ULqKGYfaxBUO8RNq-Znh4dbojghIauH4YIjYx9QU,6730
 devsecops_engine_tools/engine_core/src/domain/usecases/metrics_manager.py,sha256=Xi0iNnPrFgqd2cBdAA5E_tgouhxs-BTo016aolnGgv8,2413
 devsecops_engine_tools/engine_core/src/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -36,18 +36,18 @@ devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/aws/secret
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/azure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/azure/azure_devops.py,sha256=blI4ZrquRE4y6DJ7N2YRx1nL0wrAXvdpx0fLSUf5qwA,4831
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/defect_dojo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/defect_dojo/defect_dojo.py,sha256=KcQJvVqJ9RUJA-o5-d6DF2l5AmXNCvZJfj7swzkC_v4,13484
+devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/defect_dojo/defect_dojo.py,sha256=TN5te3osSAeURx3bcnyRQSJVH8P_PoQ0IhaER_9kWS0,15398
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/github/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/github/github_actions.py,sha256=pxlgjhX4-Dssn-XHKK8AdCOj6Ry6VcQtoDf5q8CxTks,3731
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/printer_pretty_table/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/printer_pretty_table/printer_pretty_table.py,sha256=O1waYz_6ElcOkU3Nb4suJs2ZJIo0YLoFuNXi9-j-wSs,3811
+devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/printer_pretty_table/printer_pretty_table.py,sha256=oEhsYOS5dmTtNOzpWNurWgLxth6vBhWVvVlKul9Heys,3884
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/runtime_local/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/runtime_local/runtime_local.py,sha256=2-BRh0BVuJp-IYpX5ah5uv3Tf0txm4y-tIwdo4fPH6Q,2463
 devsecops_engine_tools/engine_core/src/infrastructure/entry_points/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_core/src/infrastructure/entry_points/entry_point_core.py,sha256=v8D9F_MvS2_zQqciDXUEaCHx6oK60ESpSdh-SDz851Y,2082
+devsecops_engine_tools/engine_core/src/infrastructure/entry_points/entry_point_core.py,sha256=k6WLcv2NQj-OzV8lqmXef-Nyi9MLTzKWSWSM3qPFjvc,2081
 devsecops_engine_tools/engine_core/src/infrastructure/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_core/src/infrastructure/helpers/aws.py,sha256=wfy_PosHS0rrvkdiUYczxIcc8ZNwfqzWwqVxrmRTCBI,264
-devsecops_engine_tools/engine_core/src/infrastructure/helpers/util.py,sha256=DTruKscu64gBk-0F-xwKcqKu6_Y8HhqemSpBJxd2BTY,382
+devsecops_engine_tools/engine_core/src/infrastructure/helpers/util.py,sha256=lDtaozInb5m2R8Y-oGQasroksCRw_N_Ltz7gLkSguX8,380
 devsecops_engine_tools/engine_dast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_dast/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_dast/src/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -63,19 +63,24 @@ devsecops_engine_tools/engine_dast/src/infrastructure/helpers/__init__.py,sha256
 devsecops_engine_tools/engine_risk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_risk/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_risk/src/applications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_risk/src/applications/runner_engine_risk.py,sha256=1_9kBIxFAXAHLIcA8HK9CQrbXZgyANAR-JlDzck8G4w,558
+devsecops_engine_tools/engine_risk/src/applications/runner_engine_risk.py,sha256=slE5CxJ-I2-FW9I9MKSOhjeCdBQEzGKXdFfXJd7XPQ8,789
 devsecops_engine_tools/engine_risk/src/deployment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_risk/src/deployment/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_risk/src/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_risk/src/domain/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_risk/src/domain/model/gateways/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devsecops_engine_tools/engine_risk/src/domain/model/gateways/add_epss_gateway.py,sha256=cTm4QSxiaUt7ETCdXWZxKEus8pmEDA3e9k5b39SLDDE,178
 devsecops_engine_tools/engine_risk/src/domain/usecases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_risk/src/domain/usecases/break_build.py,sha256=G0uFO59UJspQnq3Np2M5PiXTxWDZUgJqfkVyxcuk3jI,1225
-devsecops_engine_tools/engine_risk/src/domain/usecases/handle_filters.py,sha256=ModR0sg9QNACrZl4SKNre07t4J_nK1TO1vzZw1tN1GM,541
+devsecops_engine_tools/engine_risk/src/domain/usecases/add_data.py,sha256=4wqDj-q7hJfJscvrbMDcy7tONqxdxl-CSl_TWTRUGKA,402
+devsecops_engine_tools/engine_risk/src/domain/usecases/break_build.py,sha256=5iGoHwyTPGaYEad598xmCcx_HzKx1IEPVLCQOnhgubE,11377
+devsecops_engine_tools/engine_risk/src/domain/usecases/get_exclusions.py,sha256=4wOIBwVVQDg5zUgijrFUeOcIyIbOvv32WR8a93nlEb4,2314
+devsecops_engine_tools/engine_risk/src/domain/usecases/handle_filters.py,sha256=w18CVVSs0mkfLYo7f-wZJv1afoPWzEU-IBKUzk7LMYI,832
 devsecops_engine_tools/engine_risk/src/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_risk/src/infrastructure/driven_adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devsecops_engine_tools/engine_risk/src/infrastructure/driven_adapters/first_csv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devsecops_engine_tools/engine_risk/src/infrastructure/driven_adapters/first_csv/first_epss_csv.py,sha256=pWaRmIwVyiB5mlmWySHIx-DUgN9vtKQc-MqyRNVlTJo,2150
 devsecops_engine_tools/engine_risk/src/infrastructure/entry_points/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_risk/src/infrastructure/entry_points/entry_point_risk.py,sha256=9clAw0ccvz7o8n6E-Uxtn_UKC-cVa_jp_JzIXnoYcmE,1107
+devsecops_engine_tools/engine_risk/src/infrastructure/entry_points/entry_point_risk.py,sha256=HlWPr8Mg7kjnDGDmYqJRk-dJk-V8qDhtB08uUXBPVdw,3399
 devsecops_engine_tools/engine_risk/src/infrastructure/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_sast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_sast/engine_iac/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -181,7 +186,7 @@ devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/__init_
 devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/driven_adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/driven_adapters/xray_tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/driven_adapters/xray_tool/xray_deserialize_output.py,sha256=Vm0pj1i6a34xXouXUU95Y04hzR--9tcMQuycR7IMUnQ,2221
-devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/driven_adapters/xray_tool/xray_manager_scan.py,sha256=1_jT819e8HKH-qirKtqvgyKAi16Pu0YW7OEkEqWoM_M,10052
+devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/driven_adapters/xray_tool/xray_manager_scan.py,sha256=y3W4gpyAEHZoHEZaMaeFPfJ3zmNBc2TUcYhYCSosi1E,10525
 devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/entry_points/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/entry_points/entry_point_tool.py,sha256=NBzg9VoGIqHeXuhDR4vBgwPMFnkjzJssBddPo1R23R0,2524
 devsecops_engine_tools/engine_sca/engine_dependencies/src/infrastructure/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -203,17 +208,17 @@ devsecops_engine_tools/engine_utilities/defect_dojo/domain/__init__.py,sha256=47
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/cmdb.py,sha256=7EAzKzBJaDqP4Q57cyu_nCpl9WqcTZFjXydkYCh8h-k,320
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/engagement.py,sha256=x0mkWoLv8rRHZTh7hhI1aZb2g9XFJ-Gz_gC-f-rZdWM,1372
-devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/finding.py,sha256=z_fH5_dgdPNhmp3CtZ0IY7NnkASa1rng_FOiN6BR17Q,3145
+devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/finding.py,sha256=0Xj7BOlC30LCdBjIkviB2QmmdSj0GlDvT1-TbnaT8nE,3201
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/product.py,sha256=KL5ue6icA8HH1xKkmAJzElAat3OOYU3_lt3xuNfo7Mc,1272
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/product_list.py,sha256=ExoZSaOLRVioy85EMyDSl2ktSw8f1gp30mxacQCpP74,426
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/product_type.py,sha256=2KVfRB0qgPO7osY4PBEQSOBOqRnZs0UzUZkS1guisBQ,524
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/product_type_list.py,sha256=N5m4fHCqdlZs3EM7oaAMYvbzIebkOKzqpZZVn6wpcJQ,464
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/models/scan_configuration.py,sha256=-uVxaTkxnDmUUGQUdN9x_VKR8KJUagJKnGR6B1emoEU,577
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/request_objects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_utilities/defect_dojo/domain/request_objects/finding.py,sha256=VriR9km0yYP9tYt6BjLC7EZrQIQsaNZUN45OpWv8fzk,2558
+devsecops_engine_tools/engine_utilities/defect_dojo/domain/request_objects/finding.py,sha256=RinG3ISc-u_3VXVqntwdcQvZoQdmHPCvDHWSvnkCkcU,2619
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/request_objects/import_scan.py,sha256=Y1ewQ-9wM287MSEraT4myG1RDl4LjmeqansR3-Exn7U,4974
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/finding.py,sha256=oo5AJYNtGHO0Gy76dHrLBlsZy_HRpifLOi7rzNLTJc0,5140
+devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/finding.py,sha256=HNkA_sHSMfQKAcZht-rRPdwm0eHYK2wxM6u61_bl2uE,5233
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/serializers/import_scan.py,sha256=VyV1LzeJDk51RYXz8EiweLHccpsuwTY3hTkAnkscX2E,7211
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 devsecops_engine_tools/engine_utilities/defect_dojo/domain/user_case/cmdb.py,sha256=BUOdvP39bEMQ6Unr2hB28eljVGU2Uv8dDEkzRyEJgyQ,2650
@@ -249,8 +254,8 @@ devsecops_engine_tools/engine_utilities/utils/logger_info.py,sha256=4Mz8Bwlm9Mku
 devsecops_engine_tools/engine_utilities/utils/name_conversion.py,sha256=ADJrRGaxYSDe0ZRh6VHRf53H4sXPcb-vNP_i81PUn3I,307
 devsecops_engine_tools/engine_utilities/utils/printers.py,sha256=amYAr9YQfYgR6jK9a2l26z3oovFPQ3FAKmhq6BKhEBA,623
 devsecops_engine_tools/engine_utilities/utils/session_manager.py,sha256=yNtlT-8Legz1sHbGPH8LNYjL-LgDUE0zXG2rYjiab7U,290
-devsecops_engine_tools-1.8.7.dist-info/METADATA,sha256=_n4iDlB6FQUsRY4jARO-Fv6r0BRq0Q64IwbkLUKzCSM,10221
-devsecops_engine_tools-1.8.7.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-devsecops_engine_tools-1.8.7.dist-info/entry_points.txt,sha256=9IjXF_7Zpgowq_SY6OSmsA9vZze18a8_AeHwkQVrgKk,131
-devsecops_engine_tools-1.8.7.dist-info/top_level.txt,sha256=ge6y0X_xBAU1aG3EMWFtl9djbVyg5BxuSp2r2Lg6EQU,23
-devsecops_engine_tools-1.8.7.dist-info/RECORD,,
+devsecops_engine_tools-1.8.9.dist-info/METADATA,sha256=n177JIC-KVUixW88Z2FPhidKmLaAFUPa0Eq09G2FNUA,10443
+devsecops_engine_tools-1.8.9.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+devsecops_engine_tools-1.8.9.dist-info/entry_points.txt,sha256=9IjXF_7Zpgowq_SY6OSmsA9vZze18a8_AeHwkQVrgKk,131
+devsecops_engine_tools-1.8.9.dist-info/top_level.txt,sha256=ge6y0X_xBAU1aG3EMWFtl9djbVyg5BxuSp2r2Lg6EQU,23
+devsecops_engine_tools-1.8.9.dist-info/RECORD,,