devsecops-engine-tools 1.6.7__py3-none-any.whl

devsecops_engine_tools/engine_utilities/defect_dojo/hello_world.py

@@ -0,0 +1,2 @@
+def hello_world(saludo):
+    print(saludo)

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/cmdb.py

@@ -0,0 +1,55 @@
+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.models.cmdb import Cmdb
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import ImportScanRequest
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class CmdbRestConsumer:
+    def __init__(self, token: str, host: str, mapping_cmdb: dict, session: SessionManager) -> None:
+        self.__token = token
+        self.__host = host
+        self.__mapping_cmdb = mapping_cmdb
+        self.__session = session._instance
+
+    def get_product_info(self, request: ImportScanRequest) -> Cmdb:
+        data = json.dumps({"codapp": request.code_app})
+        headers = {"tokenkey": self.__token, "Content-Type": "application/json"}
+        logger.info("Search info of name product")
+        try:
+            response = self.__session.post(self.__host, headers=headers, data=data, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 200:
+                logger.error(response)
+                raise ApiError(response.json()["Message"])
+
+            if response.json() == []:
+                e = f"Engagement: {request.code_app} not found"
+                logger.warning(e)
+                # Producto is Orphan
+                return Cmdb(
+                    product_type_name="ORPHAN_PRODUCT_TYPE",
+                    product_name=f"{request.code_app}_Product",
+                    tag_product="ORPHAN",
+                    product_description="Orphan Product Description",
+                    codigo_app=str(request.code_app),
+                )
+
+            data = response.json()[-1]
+            data_map = self.mapping_cmdb(data)
+            logger.info(data_map)
+            cmdb_object = Cmdb.from_dict(data_map)
+        except Exception as e:
+            logger.error(e)
+            raise ApiError(e)
+        return cmdb_object
+
+    def mapping_cmdb(self, data):
+        data_map = {}
+        for key, value in self.__mapping_cmdb.items():
+            data_map[key] = data[value] if value in data else ""
+        return data_map

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/engagement.py

@@ -0,0 +1,55 @@
+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.utils.session_manager import SessionManager
+from datetime import datetime
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class EngagementRestConsumer:
+    def __init__(self, request: ImportScanRequest, session: SessionManager):
+        self.__token = request.token_defect_dojo
+        self.__host = request.host_defect_dojo
+        self.__session = session._instance
+
+    def get_engagements(self, engagement_name):
+        url = f"{self.__host}/api/v2/engagements/?name={engagement_name}"
+
+        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+        try:
+            response = self.__session.get(url=url, headers=headers, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 200:
+                logger.error(response.json())
+                raise ApiError(response.json())
+            response = EngagementList().from_dict(response.json())
+        except Exception as e:
+            raise ApiError(e)
+        return response
+
+    def post_engagement(self, engagement_name, product_id):
+        url = f"{self.__host}/api/v2/engagements/"
+        data = json.dumps(
+            {
+                "name": engagement_name,
+                "target_start": str(datetime.now().date()),
+                "target_end": str(datetime.now().date()),
+                "product": product_id,
+                "engagement_type": "CI/CD",
+                "status": "In Progress",
+            }
+        )
+        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+        try:
+            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())
+            response = Engagement().from_dict(response.json())
+        except Exception as e:
+            raise ApiError(e)
+        return response

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/finding.py

@@ -0,0 +1,37 @@
+from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.finding import FindingRequest
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.finding import Finding, FindingList
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
+import json
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class FindingRestConsumer:
+    def __init__(self, session: SessionManager):
+        self.__token = session._token
+        self.__host = session._host
+        self.__session = session._instance
+
+    def get(self, request):
+        url = f"{self.__host}/api/v2/findings/"
+        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+        response = self.__session.get(url, headers=headers, data={}, params=request, verify=VERIFY_CERTIFICATE)
+        if response.status_code != 200:
+            raise ApiError(response.json())
+        findings = FindingList.from_dict(response.json())
+        return findings
+
+    def close(self, request, id):
+        url = f"{self.__host}/api/v2/findings/{id}/close/"
+        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+        response = self.__session.post(url, headers=headers, data=json.dumps(request), verify=VERIFY_CERTIFICATE)
+        if response.status_code != 200:
+            logger.error(response.json())
+            raise ApiError(response.json())
+        logger.debug(response.json())
+        logger.debug(response)
+        return response

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/import_scan.py

@@ -0,0 +1,115 @@
+from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
+from requests_toolbelt.multipart.encoder import MultipartEncoder
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.request_objects.import_scan import ImportScanRequest
+from devsecops_engine_tools.engine_utilities.utils.logger_info import MyLogger
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class ImportScanRestConsumer:
+    def __init__(self, request: ImportScanRequest, session: SessionManager):
+        self.__token = request.token_defect_dojo
+        self.__host = request.host_defect_dojo
+        self.__session = session._instance
+
+    def import_scan_api(self, request: ImportScanRequest) -> ImportScanRequest:
+        url = f"{self.__host}/api/v2/import-scan/"
+        data = {
+            "scan_date": request.scan_date,
+            "minimum_severity": request.minimum_severity,
+            "active": request.active,
+            "verified": request.verified,
+            "scan_type": request.scan_type,
+            "endpoint_to_add": request.endpoint_to_add,
+            # "file": request.file,
+            "product_type_name": request.product_type_name,
+            "product_name": request.product_name,
+            "engagement_name": request.engagement_name,
+            "engagement_end_date": request.engagement_end_date,
+            "source_code_management_uri": request.source_code_management_uri,
+            "engagement": str(request.engagement) if request.engagement != 0 else "",
+            "auto_create_context": "false",
+            "deduplication_on_engagement": request.deduplication_on_engagement,
+            "lead": request.lead,
+            "tags": request.tags,
+            "close_old_findings": str(request.close_old_findings),
+            "close_old_findings_product_scope": str(request.close_old_findings_product_scope),
+            "push_to_jira": str(request.push_to_jira),
+            "environment": request.environment,
+            "version": request.version,
+            "build_id": request.build_id,
+            "branch_tag": request.branch_tag,
+            "commit_hash": request.commit_hash,
+            "api_scan_configuration": str(request.api_scan_configuration)
+            if request.api_scan_configuration != 0
+            else "",
+            "service": request.service,
+            "group_by": request.group_by,
+        }
+        multipart_data = MultipartEncoder(fields=data)
+
+        headers = {"Authorization": f"Token {self.__token}", "Content-Type": multipart_data.content_type}
+        try:
+            response = self.__session.post(url, headers=headers, data=multipart_data, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 201:
+                logger.error(response.status_code)
+                logger.error(response.json())
+                raise ApiError(response.json())
+            response = ImportScanRequest().from_dict(response.json())
+        except Exception as e:
+            logger.error(f"from dict import Scan: {response.json()}")
+            raise ApiError(response.json())
+        return response
+
+    def import_scan(self, request: ImportScanRequest, files) -> ImportScanRequest:
+        url = f"{self.__host}/api/v2/import-scan/"
+        payload = {
+            "scan_date": request.scan_date,
+            "minimum_severity": request.minimum_severity,
+            "active": request.active,
+            "verified": request.verified,
+            "scan_type": request.scan_type,
+            "endpoint_to_add": request.endpoint_to_add,
+            "file": files,
+            "product_type_name": request.product_type_name,
+            "product_name": request.product_name,
+            "engagement_name": request.engagement_name,
+            "engagement_end_date": request.engagement_end_date,
+            "source_code_management_uri": request.source_code_management_uri,
+            "engagement": request.engagement if request.engagement != 0 else "",
+            "auto_create_context": "false",
+            "deduplication_on_engagement": request.deduplication_on_engagement,
+            "lead": request.lead,
+            "tags": request.tags,
+            "close_old_findings": request.close_old_findings,
+            "close_old_findings_product_scope": request.close_old_findings_product_scope,
+            "push_to_jira": request.push_to_jira,
+            "environment": request.environment,
+            "version": request.version,
+            "build_id": request.build_id,
+            "branch_tag": request.branch_tag,
+            "commit_hash": request.commit_hash,
+            "api_scan_configuration": str(request.api_scan_configuration)
+            if request.api_scan_configuration != 0
+            else "",
+            "service": request.service,
+            "group_by": request.group_by,
+        }
+
+        headers = {"Authorization": f"Token {self.__token}"}
+        try:
+            response = self.__session.post(url, headers=headers, data=payload, files=files, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 201:
+                logger.error(payload)
+                logger.error(response.json())
+                logger.error(response)
+                raise ApiError(response.json())
+            logger.info(f"Sucessfull {response}")
+            response = ImportScanRequest.from_dict(response.json())
+        except Exception as e:
+            logger.error(f"from dict import Scan: {response.json()}")
+            raise ApiError(e)
+        return response

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/product.py

@@ -0,0 +1,50 @@
+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.domain.models.product import Product
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.product_list import ProductList
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class ProductRestConsumer:
+    def __init__(self, request: ImportScanRequest, session: SessionManager):
+        self.__token = request.token_defect_dojo
+        self.__host = request.host_defect_dojo
+        self.__session = session._instance
+
+    def get_products(self, request: ImportScanRequest) -> ProductList:
+        url = f"{self.__host}/api/v2/products/?name={request.code_app}"
+        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+        try:
+            response = self.__session.get(url, headers=headers, data={}, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 200:
+                raise ApiError(response.json())
+            products_object = ProductList.from_dict(response.json())
+        except Exception as e:
+            logger.error(f"from dict product: {response.json()}")
+            raise ApiError(e)
+        return products_object
+
+    def post_product(self, request: ImportScanRequest, product_type_id: int) -> Product:
+        url = f"{self.__host}/api/v2/products/"
+
+        data = {
+            "name": request.product_name,
+            "description": "AREA RESPONSABLE TI: " + request.product_description.upper(),
+            "enable_full_risk_acceptance": True,
+            "prod_type": product_type_id,
+        }
+        headers = {"Authorization": f"Token {self.__token}"}
+        try:
+            response = self.__session.post(url, headers=headers, data=data, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 201:
+                raise ApiError(response.json())
+            product_object = Product.from_dict(response.json())
+        except Exception as e:
+            logger.error(f"form dict product: {response.json()}")
+            raise ApiError(e)
+        return product_object

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/product_type.py

@@ -0,0 +1,59 @@
+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.domain.models.product_type_list import ProductTypeList
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.product_type import ProductType
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class ProductTypeRestConsumer:
+    def __init__(self, request: ImportScanRequest, session: SessionManager):
+        self.__token = request.token_defect_dojo
+        self.__host = request.host_defect_dojo
+        self.__session = session._instance
+
+    def post_product_type(self, product_type_name: str) -> ProductType:
+        url = f"{self.__host}/api/v2/product_types/"
+        data = json.dumps({"name": product_type_name})
+        headers = {"Authorization": f"Token {self.__token}", "Content-Type": "application/json"}
+        try:
+            response = self.__session.post(url, headers=headers, data=data)
+            if response.status_code != 201:
+                raise ApiError(response.json())
+            product_type_object = ProductType.from_dict(response.json())
+        except Exception as e:
+            log = f"from dict product_type: {response.json}"
+            logger.error(log)
+            raise ApiError(e)
+        return product_type_object
+
+    def get_product_types(self, product_type_name: str) -> ProductTypeList:
+        url = f"{self.__host}/api/v2/product_types/?name={product_type_name}"
+        headers = {"Authorization": f"Token {self.__token}"}
+        try:
+            response = self.__session.get(url, headers=headers, data={}, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 200:
+                raise ApiError(response.json())
+            product_type_object = ProductTypeList.from_dict(response.json())
+        except Exception as e:
+            raise ApiError(e)
+        return product_type_object
+
+    def get_product_type_id(self, id: int):
+        url = f"{self.__host}/api/v2/product_types/{id}/"
+
+        headers = {"Authorization": f"Token {self.__token}"}
+        try:
+            response = self.__session.get(url, headers=headers, data={}, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 200:
+                raise ApiError(response.json())
+            logger.info(response)
+            product_type_object = ProductType.from_dict(response.json())
+        except Exception as e:
+            raise ApiError(e)
+        return product_type_object

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/scan_configurations.py

@@ -0,0 +1,65 @@
+from devsecops_engine_tools.engine_utilities.utils.api_error import ApiError
+import json
+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.domain.models.scan_configuration import (
+    ScanConfiguration,
+    ScanConfigurationList,
+)
+from devsecops_engine_tools.engine_utilities.defect_dojo.domain.models.scan_configuration import ScanConfiguration
+from devsecops_engine_tools.engine_utilities.defect_dojo.infraestructure.driver_adapters.settings.settings import VERIFY_CERTIFICATE
+from devsecops_engine_tools.engine_utilities.utils.session_manager import SessionManager
+from devsecops_engine_tools.engine_utilities.settings import SETTING_LOGGER
+
+logger = MyLogger.__call__(**SETTING_LOGGER).get_logger()
+
+
+class ScanConfigrationRestConsumer:
+    def __init__(self, request: ImportScanRequest, session: SessionManager) -> ScanConfiguration:
+        self.__token = request.token_defect_dojo
+        self.__host = request.host_defect_dojo
+        self.__session = session._instance
+
+    def post_api_scan_configuration(
+        self, request: ImportScanRequest, product_id: int, tool_configuration_id: int
+    ) -> ScanConfiguration:
+        url = f"{self.__host}/api/v2/product_api_scan_configurations/"
+
+        headers = {
+            "Authorization": f"Token {self.__token}",
+            "Content-Type": "application/json",
+        }
+
+        data = json.dumps(
+            {
+                "service_key_1": request.engagement_name,
+                "product": product_id,
+                "tool_configuration": tool_configuration_id,
+            }
+        )
+        try:
+            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())
+            scan_configuration_object = ScanConfiguration.from_dict(response.json())
+        except Exception as e:
+            logger.error(f"from dict scanConfiguration {response.json()}")
+            raise ApiError(e)
+        return scan_configuration_object
+
+    def get_api_scan_configuration(self, request: ImportScanRequest) -> ScanConfigurationList:
+        url = f"{self.__host}/api/v2/product_api_scan_configurations/?service_key_1={request.engagement_name}"
+        headers = {
+            "Authorization": f"Token {self.__token}",
+            "Conten-Type": "application/json",
+        }
+        try:
+            response = self.__session.get(url=url, headers=headers, verify=VERIFY_CERTIFICATE)
+            if response.status_code != 200:
+                logger.error(response.json())
+                raise ApiError(response.json())
+            response = ScanConfigurationList.from_dict(response.json())
+        except Exception as e:
+            raise ApiError(e)
+        return response

devsecops_engine_tools/engine_utilities/defect_dojo/infraestructure/driver_adapters/settings/settings.py

@@ -0,0 +1 @@
+VERIFY_CERTIFICATE = False

devsecops_engine_tools/engine_utilities/github/infrastructure/github_api.py

@@ -0,0 +1,49 @@
+import requests
+import zipfile
+
+
+class GithubApi:
+    def __init__(
+        self,
+        token: str = ""
+    ):
+        self.token = token
+
+    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 download_latest_release_assets(
+        self, owner, repository, download_path="."
+    ):
+        url = f"https://api.github.com/repos/{owner}/{repository}/releases/latest"
+
+        headers = {"Authorization": f"token {self.token}"}
+
+        response = requests.get(url, headers=headers)
+
+        if response.status_code == 200:
+            latest_release = response.json()
+            assets = latest_release["assets"]
+
+            for asset in assets:
+                asset_url = asset["url"]
+                asset_name = asset["name"]
+
+                headers.update({"Accept": "application/octet-stream"})
+
+                response = requests.get(asset_url, headers=headers, stream=True)
+
+                if response.status_code == 200:
+                    with open(f"{download_path}/{asset_name}", "wb") as file:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            file.write(chunk)
+                    self.unzip_file(f"{download_path}/{asset_name}", download_path)
+                else:
+                    print(
+                        f"Error downloading asset {asset_name}. status code: {response.status_code}"
+                    )
+        else:
+            print(
+                f"Error getting the assets of the last release. Status code: {response.status_code}"
+            )

devsecops_engine_tools/engine_utilities/input_validations/env_utils.py

@@ -0,0 +1,10 @@
+import os
+
+
+class EnvVariables:
+    @staticmethod
+    def get_value(env_name):
+        env_var = os.environ.get(env_name)
+        if env_var is None:
+            raise ValueError(f"La variable de entorno {env_name} no está definida")
+        return env_var

devsecops_engine_tools/engine_utilities/input_validations/validate_input_with_regex_letters_number_and_only.py

@@ -0,0 +1,8 @@
+import re
+
+
+def validate_input_with_regex(value, input_name):
+    pattern = r"^[a-zA-Z0-9_]+$"
+    if not re.match(pattern, value):
+        raise ValueError(f"Error: Invalid input for {input_name}. Only letters and numbers are allowed.")
+    return value

devsecops_engine_tools/engine_utilities/settings.py

@@ -0,0 +1,38 @@
+import os
+import json
+import platform
+from decouple import config
+
+# common_devsecops_lib settings
+DEVSECOPS_ENGINE_UTILITIES_PATH = os.path.dirname(os.path.realpath(__file__))
+DEVSECOPS_ENGINE_UTILITIES_RUNNER_PLATFORM_SYSTEM = platform.system()
+DEVSECOPS_ENGINE_UTILITIES_RUNNER_PLATFORM_RELEASE = platform.release()
+DEVSECOPS_ENGINE_UTILITIES_RUNNER_PYTHON_VERSION = platform.python_version()
+DEVSECOPS_ENGINE_UTILITIES_RUNNER_PYTHON_COMPILER = platform.python_compiler()
+
+# logging settings
+DEBUG_DEVSECOPS = config("DEBUG_DEVSECOPS", default=False, cast=bool)
+LOG_CONSOLE_DEVSECOPS = config("LOG_CONSOLE_DEVSECOPS", default=False, cast=bool)
+FILE_DEBUG_DEVSECOPS = config("FILE_DEBUG_DEVSECOPS", default=False, cast=bool)
+FILE_FORMAT_DEBUG_DEVSECOPS = config("FILE_FORMAT_DEBUG_DEVSECOPS", default="log", cast=str)
+SETTING_LOGGER = {"debug": DEBUG_DEVSECOPS, "log_console": LOG_CONSOLE_DEVSECOPS, "log_file": FILE_DEBUG_DEVSECOPS, "log_file_format": FILE_FORMAT_DEBUG_DEVSECOPS}
+
+# defect-dojo settings
+INTEGRATION_TEST = config("INTEGRATION_TEST", default=False, cast=bool)
+ORGANIZATION_URL = config("ORGANIZATION_URL", default="")
+PERSONAL_ACCESS_TOKEN = config("PERSONAL_ACCESS_TOKEN", default="", cast=str)
+REPOSITORY_ID = config("REPOSITORY_ID", default="", cast=str)
+REMOTE_CONFIG_PATH = config("REMOTE_CONFIG_PATH", default="")
+PROJECT_REMOTE_CONFIG = config("PROJECT_REMOTE_CONFIG", default="", cast=str)
+TOKEN_CMDB = config("TOKEN_CMDB", default="", cast=str)
+HOST_CMDB = config("HOST_CMDB", default="", cast=str)
+EXPRESSION = config("EXPRESSION", default="", cast=str)
+TOKEN_DEFECT_DOJO = config("TOKEN_DEFECT_DOJO", default="", cast=str)
+HOST_DEFECT_DOJO = config("HOST_DEFECT_DOJO", default="", cast=str)
+SCAN_TYPE = config("SCAN_TYPE", default="", cast=str)
+CMDB_MAPPING = json.loads(config("CMDB_MAPPING", default={}, cast=str))
+ENGAGEMENT_NAME = config("ENGAGEMENT_NAME", default="", cast=str)
+FILE = config("FILE", default="", cast=str)
+TAGS = config("TAGS", default="", cast=str)
+COMPACT_REMOTE_CONFIG_URL = config("COMPACT_REMOTE_CONFIG_URL", default="", cast=str)
+BRANCH_TAG = config("BRANCH_TAG", default="", cast=str)

devsecops_engine_tools/engine_utilities/ssh/managment_private_key.py

@@ -0,0 +1,67 @@
+import os
+import pexpect
+import base64
+
+
+def decode_base64(secret_data, key_name):
+    key_name_secret = secret_data[key_name]
+    return base64.b64decode(key_name_secret).decode("utf-8")
+
+
+def config_knowns_hosts(host, ssh_key):
+    try:
+        ssh_directory = os.path.expanduser("~/.ssh")
+        if not os.path.exists(ssh_directory):
+            os.makedirs(ssh_directory)
+
+        known_hosts_file_path = os.path.expanduser("~/.ssh/known_hosts")
+        line_to_add = f"{host} ssh-rsa {ssh_key}\n"
+        if not os.path.exists(known_hosts_file_path):
+            with open(known_hosts_file_path, "w") as known_hosts_file:
+                known_hosts_file.write(line_to_add)
+        else:
+            with open(known_hosts_file_path, "a") as known_hosts_file:
+                known_hosts_file.write(line_to_add)
+    except Exception as e:
+        print(f"An error ocurred while configuring file: {e}")
+
+
+def create_ssh_private_file(ssh_key_file_path, ssh_key_content):
+    try:
+        with open(ssh_key_file_path, "w") as archivo:
+            archivo.write(ssh_key_content)
+        permisos = 0o600
+
+        os.chmod(ssh_key_file_path, permisos)
+    except Exception as e:
+        print(f"An error ocurred creating file: {e}")
+
+
+def add_ssh_private_key(ssh_key_file_path, ssh_key_password):
+    try:
+        # Iniciar un nuevo shell y evaluar el comando ssh-agent
+        pexpect.spawn("ssh-agent -k")
+        ssh_process = pexpect.spawn("ssh-agent -s")
+        ssh_process.expect("SSH_AUTH_SOCK=(.*?);")
+        ssh_auth_sock = ssh_process.match.group(1).decode()
+        ssh_process.expect("SSH_AGENT_PID=(.*?);")
+        ssh_agent_pid = ssh_process.match.group(1).decode()
+
+        agent_env = {"SSH_AUTH_SOCK": ssh_auth_sock, "SSH_AGENT_PID": ssh_agent_pid}
+
+        # Esperar a que se complete la inicialización de ssh-agent
+        ssh_process.expect(pexpect.EOF)
+
+        # Agregar la clave privada al ssh-agent proporcionando la contraseña
+        ssh_add_process = pexpect.spawn(f"ssh-add {ssh_key_file_path}", env=agent_env)
+
+        # Esperar la solicitud de contraseña y proporcionarla
+        ssh_add_process.expect("Enter passphrase", timeout=5)
+        ssh_add_process.sendline(ssh_key_password)
+
+        # Esperar a que se complete la operación
+        ssh_add_process.expect(pexpect.EOF)
+
+        return agent_env
+    except Exception as e:
+        print(f"An error ocurred adding private key: {e}")