devsecops-engine-tools 1.14.5__tar.gz → 1.15.0__tar.gz

{devsecops_engine_tools-1.14.5 → devsecops_engine_tools-1.15.0}/PKG-INFO

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

{devsecops_engine_tools-1.14.5 → devsecops_engine_tools-1.15.0}/devsecops_engine_tools/engine_core/src/domain/model/gateway/vulnerability_management_gateway.py

@@ -1,7 +1,7 @@
 from abc import ABCMeta, abstractmethod
 
 from devsecops_engine_tools.engine_core.src.domain.model.vulnerability_management import VulnerabilityManagement
-
+from devsecops_engine_tools.engine_core.src.domain.model.gateway.devops_platform_gateway import DevopsPlatformGateway
 
 class VulnerabilityManagementGateway(metaclass=ABCMeta):
     @abstractmethod

{devsecops_engine_tools-1.14.5 → devsecops_engine_tools-1.15.0}/devsecops_engine_tools/engine_core/src/domain/model/report.py

@@ -31,4 +31,6 @@ class Report:
         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", "")
+        self.endpoints = kwargs.get("endpoints", "")
+        self.unique_id_from_tool = kwargs.get("unique_id_from_tool", "")
+        self.out_of_scope = kwargs.get("out_of_scope", "")

{devsecops_engine_tools-1.14.5 → devsecops_engine_tools-1.15.0}/devsecops_engine_tools/engine_core/src/infrastructure/driven_adapters/defect_dojo/defect_dojo.py

@@ -5,6 +5,9 @@ from devsecops_engine_tools.engine_core.src.domain.model.gateway.vulnerability_m
 from devsecops_engine_tools.engine_core.src.domain.model.vulnerability_management import (
     VulnerabilityManagement,
 )
+from devsecops_engine_tools.engine_core.src.domain.model.gateway.devops_platform_gateway import (
+    DevopsPlatformGateway
+)
 from devsecops_engine_tools.engine_utilities.defect_dojo import (
     DefectDojo,
     ImportScanRequest,
@@ -67,7 +70,8 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
                 "KUBESCAPE": "Kubescape Scanner",
                 "KICS": "KICS Scanner",
                 "BEARER": "Bearer CLI",
-                "DEPENDENCY_CHECK": "Dependency Check Scan"
+                "DEPENDENCY_CHECK": "Dependency Check Scan",
+                "SONARQUBE": "SonarQube API Import"
             }
 
             if any(
@@ -426,6 +430,8 @@ class DefectDojoPlatform(VulnerabilityManagementGateway):
             risk_accepted=finding.risk_accepted,
             false_p=finding.false_p,
             service=finding.service,
+            unique_id_from_tool=finding.unique_id_from_tool,
+            out_of_scope=finding.out_of_scope
         )
 
     def _format_date_to_dd_format(self, date_string):

{devsecops_engine_tools-1.14.5 → devsecops_engine_tools-1.15.0}/devsecops_engine_tools/engine_sast/engine_secret/src/infrastructure/driven_adapters/trufflehog/trufflehog_run.py

@@ -126,10 +126,10 @@ class TrufflehogRun(ToolGateway):
         repository_name,
         enable_custom_rules
     ):
-        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 + '/' + repository_name} --include-paths {include_path} --exclude-paths {exclude_path} --no-verification --no-update --json"
 
         if enable_custom_rules == "true":
-            command = command.replace("--no-verification --json", "--config /tmp/rules/trufflehog/custom-rules.yaml --no-verification --json")
+            command = command.replace("--no-verification --json", "--config /tmp/rules/trufflehog/custom-rules.yaml --no-verification --no-update --json")
 
         result = subprocess.run(command, capture_output=True, shell=True, text=True, encoding='utf-8')
         return result.stdout.strip()

devsecops_engine_tools-1.15.0/devsecops_engine_tools/engine_utilities/sonarqube/src/applications/runner_report_sonar.py

@@ -0,0 +1,110 @@
+from devsecops_engine_tools.engine_core.src.infrastructure.driven_adapters.aws.secrets_manager import (
+    SecretsManager
+)
+from devsecops_engine_tools.engine_core.src.infrastructure.driven_adapters.azure.azure_devops import (
+    AzureDevops
+)
+from devsecops_engine_tools.engine_core.src.infrastructure.driven_adapters.defect_dojo.defect_dojo import (
+    DefectDojoPlatform
+)
+from devsecops_engine_tools.engine_utilities.sonarqube.src.infrastructure.driven_adapters.sonarqube.sonarqube_report import(
+    SonarAdapter
+)
+from devsecops_engine_tools.engine_core.src.infrastructure.driven_adapters.aws.s3_manager import (
+    S3Manager,
+)
+from devsecops_engine_tools.engine_utilities.sonarqube.src.infrastructure.entry_points.entry_point_report_sonar import (
+    init_report_sonar
+)
+import sys
+import argparse
+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()
+
+def get_inputs_from_cli(args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-rcf",
+        "--remote_config_repo",
+        type=str,
+        required=True,
+        help="Name of Config Repo",
+    )
+    parser.add_argument(
+        "--use_secrets_manager",
+        choices=["true", "false"],
+        type=str,
+        required=True,
+        help="Use Secrets Manager to get the tokens",
+    )
+    parser.add_argument(
+        "--send_metrics",
+        choices=["true", "false"],
+        type=str,
+        required=False,
+        help="Enable or Disable the send metrics to the driven adapter metrics",
+    )
+    parser.add_argument(
+        "--sonar_url",
+        required=False,
+        help="Url to access sonar API",
+    )
+    parser.add_argument(
+        "--token_cmdb", 
+        required=False, 
+        help="Token to connect to the CMDB"
+    )
+    parser.add_argument(
+        "--token_vulnerability_management",
+        required=False,
+        help="Token to connect to the Vulnerability Management",
+    )
+    parser.add_argument(
+        "--token_sonar",
+        required=False,
+        help="Token to access sonar server",
+    )
+
+    args = parser.parse_args()
+    return {
+        "remote_config_repo": args.remote_config_repo,
+        "use_secrets_manager": args.use_secrets_manager,
+        "send_metrics": args.send_metrics,
+        "sonar_url": args.sonar_url,
+        "token_cmdb": args.token_cmdb,
+        "token_vulnerability_management": args.token_vulnerability_management,
+        "token_sonar": args.token_sonar,
+    }
+
+def runner_report_sonar():
+    try:
+        vulnerability_management_gateway = DefectDojoPlatform()
+        secrets_manager_gateway = SecretsManager()
+        devops_platform_gateway = AzureDevops()
+        sonar_gateway = SonarAdapter()
+        metrics_manager_gateway = S3Manager()
+        args = get_inputs_from_cli(sys.argv[1:])
+
+        init_report_sonar(
+            vulnerability_management_gateway=vulnerability_management_gateway,
+            secrets_manager_gateway=secrets_manager_gateway,
+            devops_platform_gateway=devops_platform_gateway,
+            sonar_gateway=sonar_gateway,
+            metrics_manager_gateway=metrics_manager_gateway,
+            args=args,
+        )
+
+    except Exception as e:
+        logger.error("Error report_sonar: {0} ".format(str(e)))
+        print(
+            devops_platform_gateway.message(
+                "error", "Error report_sonar: {0} ".format(str(e))
+            )
+        )
+        print(devops_platform_gateway.result_pipeline("failed"))
+
+
+if __name__ == "__main__":
+    runner_report_sonar()

devsecops_engine_tools-1.15.0/devsecops_engine_tools/engine_utilities/sonarqube/src/domain/model/gateways/sonar_gateway.py

@@ -0,0 +1,63 @@
+from abc import (
+    ABCMeta,
+    abstractmethod
+)
+
+class SonarGateway(metaclass=ABCMeta):
+    @abstractmethod
+    def get_project_keys(
+        self,
+        pipeline_name: str
+    ):
+        "get sonar project keys"
+
+    @abstractmethod
+    def parse_project_key(
+        self,
+        file_path: str
+    ):
+        "find project key in metadata file"
+
+    @abstractmethod
+    def create_task_report_from_string(
+        self,
+        file_content: str
+    ):
+        "make dict from metadata file"
+
+    @abstractmethod
+    def filter_by_sonarqube_tag(
+        self,
+        findings: list
+    ):
+        "search for sonar findings"
+    
+    @abstractmethod
+    def change_finding_status(
+        self,
+        sonar_url: str,
+        sonar_token: str,
+        endpoint: str,
+        data: dict,
+        finding_type: str
+    ):
+        "use API to change vulnerabilities state in sonar"
+
+    @abstractmethod
+    def get_findings(
+        self,
+        sonar_url: str,
+        sonar_token: str,
+        endpoint: str,
+        params: dict,
+        finding_type: str
+    ):
+        "use API to get project findings in sonar"
+
+    @abstractmethod
+    def search_finding_by_id(
+        self,
+        findings: list,
+        finding_id: str
+    ):
+        "search a finding by id"

devsecops_engine_tools-1.15.0/devsecops_engine_tools/engine_utilities/sonarqube/src/domain/usecases/report_sonar.py

@@ -0,0 +1,194 @@
+from devsecops_engine_tools.engine_utilities.sonarqube.src.infrastructure.helpers.utils import (
+    set_repository
+)
+from devsecops_engine_tools.engine_core.src.infrastructure.helpers.util import (
+    define_env
+)
+from devsecops_engine_tools.engine_core.src.domain.model.gateway.vulnerability_management_gateway import (
+    VulnerabilityManagementGateway
+)
+from devsecops_engine_tools.engine_core.src.domain.model.vulnerability_management import (
+    VulnerabilityManagement
+)
+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_utilities.sonarqube.src.domain.model.gateways.sonar_gateway import (
+    SonarGateway
+)
+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 ReportSonar:
+    def __init__(
+        self,
+        vulnerability_management_gateway: VulnerabilityManagementGateway,
+        secrets_manager_gateway: SecretsManagerGateway,
+        devops_platform_gateway: DevopsPlatformGateway,
+        sonar_gateway: SonarGateway
+    ):
+        self.vulnerability_management_gateway = vulnerability_management_gateway
+        self.secrets_manager_gateway = secrets_manager_gateway
+        self.devops_platform_gateway = devops_platform_gateway
+        self.sonar_gateway = sonar_gateway
+
+    def process(self, args):
+        pipeline_name = self.devops_platform_gateway.get_variable("pipeline_name")
+        branch = self.devops_platform_gateway.get_variable("branch_name")
+        input_core = InputCore(
+            [],
+            {},
+            "",
+            "",
+            "",
+            self.devops_platform_gateway.get_variable("stage").capitalize(),
+        )
+
+        compact_remote_config_url = self.devops_platform_gateway.get_base_compact_remote_config_url(args["remote_config_repo"])
+        source_code_management_uri = set_repository(
+            pipeline_name,
+            self.devops_platform_gateway.get_source_code_management_uri()
+        )
+        config_tool = self.devops_platform_gateway.get_remote_config(
+            args["remote_config_repo"],
+            "/engine_core/ConfigTool.json"
+        )
+        environment = define_env(None, branch)
+        
+        if args["use_secrets_manager"] == "true": 
+            secret = self.secrets_manager_gateway.get_secret(config_tool)
+        else: 
+            secret = args
+
+        report_config_tool = self.devops_platform_gateway.get_remote_config(
+            args["remote_config_repo"],
+            "/report_sonar/ConfigTool.json"
+        )
+
+        get_components = report_config_tool["PIPELINE_COMPONENTS"].get(pipeline_name)
+        if get_components:
+            project_keys = [f"{pipeline_name}_{component}" for component in get_components]
+            print(f"Multiple project keys detected: {project_keys}")
+            logger.info(f"Multiple project keys detected: {project_keys}")
+        else:
+            project_keys = self.sonar_gateway.get_project_keys(pipeline_name)
+
+        args["tool"] = "sonarqube"
+        vulnerability_manager = VulnerabilityManagement(
+            scan_type = "SONARQUBE",
+            input_core = input_core,
+            dict_args = args,
+            secret_tool = self.secrets_manager_gateway,
+            config_tool = config_tool,
+            source_code_management_uri = source_code_management_uri,
+            base_compact_remote_config_url = compact_remote_config_url,
+            access_token = self.devops_platform_gateway.get_variable("access_token"),
+            version = self.devops_platform_gateway.get_variable("build_execution_id"),
+            build_id = self.devops_platform_gateway.get_variable("build_id"),
+            branch_tag = branch,
+            commit_hash = self.devops_platform_gateway.get_variable("commit_hash"),
+            environment = environment
+        )
+
+        for project_key in project_keys:
+            try:
+                findings = self.vulnerability_management_gateway.get_all(
+                    service=project_key,
+                    dict_args=args,
+                    secret_tool=self.secrets_manager_gateway,
+                    config_tool=config_tool
+                )[0]
+                filtered_findings = self.sonar_gateway.filter_by_sonarqube_tag(findings)
+
+                sonar_vulnerabilities = self.sonar_gateway.get_findings(
+                    args["sonar_url"],
+                    secret["token_sonar"],
+                    "/api/issues/search",
+                    {
+                        "componentKeys": project_key,
+                        "types": "VULNERABILITY",
+                        "ps": 500,
+                        "p": 1,
+                        "s": "CREATION_DATE",
+                        "asc": "false"
+                    },
+                    "issues"
+                )
+                sonar_hotspots = self.sonar_gateway.get_findings(
+                    args["sonar_url"],
+                    secret["token_sonar"],
+                    "/api/hotspots/search",
+                    {
+                        "projectKey": project_key,
+                        "ps": 100,
+                        "p": 1,
+                    },
+                    "hotspots"
+                )
+
+                sonar_findings = sonar_vulnerabilities + sonar_hotspots
+
+                for finding in filtered_findings:
+                    related_sonar_finding = self.sonar_gateway.search_finding_by_id(
+                        sonar_findings, 
+                        finding.unique_id_from_tool
+                    )
+                    status = None
+                    if related_sonar_finding:
+                        if related_sonar_finding.get("type") == "VULNERABILITY":
+                            if finding.active and related_sonar_finding["status"] == "RESOLVED": status = "reopen"
+                            elif related_sonar_finding["status"] != "RESOLVED":
+                                if finding.false_p: status = "falsepositive"
+                                elif finding.risk_accepted: status = "close"
+                                elif finding.risk_accepted or finding.out_of_scope: status = "wontfix"
+                            if status:
+                                self.sonar_gateway.change_finding_status(
+                                    args["sonar_url"],
+                                    secret["token_sonar"],
+                                    "/api/issues/do_transition",
+                                    {
+                                        "issue": related_sonar_finding["key"],
+                                        "transition": status
+                                    },
+                                    "issue"
+                                )
+                        else:
+                            resolution = None
+                            if finding.active and related_sonar_finding["status"] == "REVIEWED": status = "TO_REVIEW"
+                            elif related_sonar_finding["status"] == "TO_REVIEW":
+                                if finding.false_p: resolution = "SAFE"
+                                elif finding.risk_accepted or finding.out_of_scope: resolution = "ACKNOWLEDGED"
+                                if resolution: status = "REVIEWED"
+                            if status:
+                                data = {
+                                    "hotspot": related_sonar_finding["key"],
+                                    "status": status,
+                                    "resolution": resolution
+                                }
+                                if not resolution: data.pop("resolution")
+                                self.sonar_gateway.change_finding_status(
+                                    args["sonar_url"],
+                                    secret["token_sonar"],
+                                    "/api/hotspots/change_status",
+                                    data,
+                                    "hotspot"
+                                )
+
+            except Exception as e:
+                logger.warning(f"It was not possible to synchronize Sonar and Vulnerability Manager: {e}")
+
+            input_core.scope_pipeline = project_key
+            self.vulnerability_management_gateway.send_vulnerability_management(
+                vulnerability_management=vulnerability_manager
+            )
+
+        input_core.scope_pipeline = pipeline_name
+        return input_core

devsecops_engine_tools-1.15.0/devsecops_engine_tools/engine_utilities/sonarqube/src/infrastructure/driven_adapters/sonarqube/sonarqube_report.py

@@ -0,0 +1,112 @@
+from devsecops_engine_tools.engine_utilities.utils.utils import (
+    Utils
+)
+from devsecops_engine_tools.engine_utilities.sonarqube.src.domain.model.gateways.sonar_gateway import (
+    SonarGateway
+)
+import os
+import re
+import requests
+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 SonarAdapter(SonarGateway):
+    def get_project_keys(self, pipeline_name):
+        project_keys = [pipeline_name]
+        sonar_scanner_params = os.getenv("SONARQUBE_SCANNER_PARAMS", "")
+        pattern = r'"sonar\.scanner\.metadataFilePath":"(.*?)"'
+        match_result = re.search(pattern, sonar_scanner_params)
+        
+        if match_result and match_result.group(1):
+            metadata_file_path = match_result.group(1)
+            project_key_found = self.parse_project_key(metadata_file_path)
+            
+            if project_key_found:
+                print(f"ProjectKey scanner params: {project_key_found}")
+                project_keys = [project_key_found]
+        
+        return project_keys
+
+    def parse_project_key(self, file_path):
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                file_content = f.read()
+                print(f"[SQ] Parse Task report file:\n{file_content}")
+                if not file_content or len(file_content) <= 0:
+                    print("[SQ] Error reading file")
+                    logger.warning("[SQ] Error reading file")
+                    return None
+                try:
+                    settings = self.create_task_report_from_string(file_content)
+                    return settings.get("projectKey")
+                except Exception as err:
+                    print(f"[SQ] Parse Task report error: {err}")
+                    logger.warning(f"[SQ] Parse Task report error: {err}")
+                    return None
+        except Exception as err:
+            logger.warning(f"[SQ] Error reading file: {str(err)}")
+            return None
+
+    def create_task_report_from_string(self, file_content):
+        lines = file_content.replace('\r\n', '\n').split('\n')
+        settings = {}
+        for line in lines:
+            split_line = line.split('=')
+            if len(split_line) > 1:
+                settings[split_line[0]] = '='.join(split_line[1:])
+        return settings
+    
+    def filter_by_sonarqube_tag(self, findings):
+        return [finding for finding in findings if "sonarqube" in finding.tags]
+    
+    def change_finding_status(self, sonar_url, sonar_token, endpoint, data, finding_type):
+        try:
+            response = requests.post(
+                f"{sonar_url}{endpoint}",
+                headers={
+                    "Authorization": f"Basic {Utils().encode_token_to_base64(sonar_token)}"
+                },
+                data=data
+            )
+            response.raise_for_status()
+
+            if finding_type == "issue": 
+                info = data["transition"]
+            else:
+                resolution_info = ""
+                if data.get("resolution"): resolution_info = f" ({data['resolution']})"
+
+                info = f"{data['status']}{resolution_info}"
+
+            print(f"The state of the {finding_type} {data[finding_type]} was changed to {info}.")
+        except Exception as e:
+            logger.warning(f"Unable to change the status of {finding_type} {data[finding_type]}. Error: {e}")
+            pass
+
+    def get_findings(self, sonar_url, sonar_token, endpoint, params, finding_type):
+        findings = []
+        try:
+            while True:
+                response = requests.get(
+                    f"{sonar_url}{endpoint}",
+                    headers={
+                        "Authorization": f"Basic {Utils().encode_token_to_base64(sonar_token)}"
+                    },
+                    params=params
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                findings.extend(data[finding_type])
+                if len(data[finding_type]) < params["ps"]: break
+                params["p"] = params["p"] + 1
+
+            return findings
+        except Exception as e:
+            logger.warning(f"It was not possible to obtain the {finding_type}: {str(e)}")
+            return []
+
+    def search_finding_by_id(self, issues, issue_id):
+        return next((issue for issue in issues if issue["key"] in issue_id), None)

devsecops_engine_tools-1.15.0/devsecops_engine_tools/engine_utilities/sonarqube/src/infrastructure/entry_points/entry_point_report_sonar.py

@@ -0,0 +1,37 @@
+from devsecops_engine_tools.engine_utilities.sonarqube.src.domain.usecases.report_sonar import (
+    ReportSonar
+)
+from devsecops_engine_tools.engine_utilities.utils.printers import (
+    Printers,
+)
+from devsecops_engine_tools.engine_core.src.domain.usecases.metrics_manager import (
+    MetricsManager,
+)
+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()
+
+def init_report_sonar(vulnerability_management_gateway, secrets_manager_gateway, devops_platform_gateway, sonar_gateway, metrics_manager_gateway, args):
+    config_tool = devops_platform_gateway.get_remote_config(
+        args["remote_config_repo"], "/engine_core/ConfigTool.json"
+    )
+    Printers.print_logo_tool(config_tool["BANNER"])
+
+    if config_tool["REPORT_SONAR"]["ENABLED"] == "true":
+        input_core = ReportSonar(
+            vulnerability_management_gateway,
+            secrets_manager_gateway, 
+            devops_platform_gateway, 
+            sonar_gateway
+        ).process(args)
+        
+        if args["send_metrics"] == "true":
+            MetricsManager(devops_platform_gateway, metrics_manager_gateway).process(
+                config_tool, input_core, {"tool": "report_sonar"}, ""
+            )
+    else:
+        print(
+            devops_platform_gateway.message(
+                "warning", "DevSecOps Engine Tool - {0} in maintenance...".format("report_sonar")),
+        )

devsecops_engine_tools-1.15.0/devsecops_engine_tools/engine_utilities/sonarqube/src/infrastructure/helpers/utils.py

@@ -0,0 +1,8 @@
+import re
+
+def set_repository(pipeline_name, source_code_management):
+    if re.search('_MR_', pipeline_name) is None:
+        return source_code_management
+    else:
+        splittedPipeline = pipeline_name.split('_MR_')
+        return source_code_management + '?path=/' + splittedPipeline[1]

devsecops_engine_tools-1.15.0/devsecops_engine_tools/engine_utilities/utils/utils.py

@@ -0,0 +1,13 @@
+import zipfile
+import base64
+
+class Utils:
+
+    def unzip_file(self, zip_file_path, extract_path):
+        with zipfile.ZipFile(zip_file_path, "r") as zip_ref:
+            zip_ref.extractall(extract_path)
+
+    def encode_token_to_base64(self, token):
+        token_bytes = f"{token}:".encode("utf-8")
+        base64_token = base64.b64encode(token_bytes).decode("utf-8")
+        return base64_token

devsecops_engine_tools-1.15.0/devsecops_engine_tools/version.py

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

{devsecops_engine_tools-1.14.5 → devsecops_engine_tools-1.15.0}/devsecops_engine_tools.egg-info/PKG-INFO

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