regscale-cli 6.16.2.0__py3-none-any.whl → 6.16.4.0__py3-none-any.whl

regscale/models/integration_models/tenable_models/integration.py

@@ -9,7 +9,12 @@ from typing import Any, Iterator, List, Optional, Tuple
 from regscale.core.app.utils.app_utils import epoch_to_datetime
 from regscale.integrations.commercial.tenablev2.utils import get_filtered_severities
 from regscale.integrations.integration_override import IntegrationOverride
-from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding, ScannerIntegration
+from regscale.integrations.scanner_integration import (
+    IntegrationAsset,
+    IntegrationFinding,
+    ScannerIntegration,
+    issue_due_date,
+)
 from regscale.models import regscale_models
 from regscale.models.integration_models.tenable_models.models import TenableAsset
 
@@ -32,6 +37,16 @@ class SCIntegration(ScannerIntegration):
     title = "Tenable SC"
     asset_identifier_field = "tenableId"
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Initializes the SCIntegration class
+
+        :param Tuple args: Additional arguments
+        :param dict kwargs: Additional keyword arguments
+        """
+        super().__init__(*args, **kwargs)
+        self.scan_date = kwargs.get("scan_date")
+
     def fetch_assets(self, *args: Any, **kwargs: Any) -> Iterator[IntegrationAsset]:
         """
         Fetches assets from SCIntegration
@@ -138,6 +153,7 @@ class SCIntegration(ScannerIntegration):
             fixed_versions = re.findall(r"Fixed version\s*:\s*(.+)", vuln.pluginText)
             fixed_versions_str = ", ".join(fixed_versions)
 
+        first_seen = epoch_to_datetime(vuln.firstSeen) if vuln.firstSeen else self.scan_date
         return IntegrationFinding(
             control_labels=[],  # Add an empty list for control_labels
             category="Tenable SC Vulnerability",  # Add a default category
@@ -148,9 +164,9 @@ class SCIntegration(ScannerIntegration):
             status=regscale_models.IssueStatus.Open,  # Findings of > Low are considered as FAIL
             asset_identifier=asset_identifier,
             external_id=vuln.pluginID,  # Weakness Source Identifier
-            first_seen=epoch_to_datetime(vuln.firstSeen),
+            first_seen=first_seen,
             last_seen=epoch_to_datetime(vuln.lastSeen),
-            date_created=epoch_to_datetime(vuln.firstSeen),
+            date_created=first_seen,
             date_last_updated=epoch_to_datetime(vuln.lastSeen),
             recommendation_for_mitigation=vuln.solution,
             cve=cve,
@@ -175,6 +191,10 @@ class SCIntegration(ScannerIntegration):
             installed_versions=installed_versions_str,
             fixed_versions=fixed_versions_str,
             fix_status="",
+            scan_date=self.scan_date,
+            due_date=issue_due_date(
+                severity=severity, created_date=first_seen, title="tenable", config=self.app.config
+            ),
         )
 
     def get_cvss_scores(self, vuln: TenableAsset) -> dict:

regscale/models/integration_models/veracode.py

@@ -1,8 +1,9 @@
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from regscale.core.app.logz import create_logger
 from regscale.core.app.utils.app_utils import get_current_datetime
-from regscale.models import Asset, Vulnerability, Mapping, ImportValidater
+from regscale.integrations.scanner_integration import IntegrationFinding
+from regscale.models import Asset, Vulnerability, ImportValidater, IssueStatus
 from regscale.models.integration_models.flat_file_importer import FlatFileImporter
 
 APP_NAME = "@app_name"
@@ -17,26 +18,34 @@ class Veracode(FlatFileImporter):
         self.vuln_title = "PROBLEM_TITLE"
         self.fmt = "%Y-%m-%d"
         self.dt_format = "%Y-%m-%d %H:%M:%S"
-        csv_headers = [
+        xlsx_headers = [
             "Source",
         ]
         xml_headers = [
             "app_name",
         ]
+        json_headers = [
+            "findings",
+            "project_name",
+        ]
         self.mapping_file = kwargs.get("mappings_path")
         self.disable_mapping = kwargs.get("disable_mapping")
         file_type = kwargs.get("file_type")
-        if file_type == ".xml":
+        xml_tag = None
+        if "xml" in file_type:
             self.required_headers = xml_headers
             xml_tag = "detailedreport"
+        elif "xlsx" in file_type:
+            self.required_headers = xlsx_headers
         else:
-            self.required_headers = csv_headers
-            xml_tag = None
+            self.required_headers = json_headers
         self.validater = ImportValidater(
             self.required_headers, kwargs.get("file_path"), self.mapping_file, self.disable_mapping, xml_tag=xml_tag
         )
         self.headers = self.validater.parsed_headers
         self.mapping = self.validater.mapping
+        if file_type == ".json":
+            self.asset_identifier = self.mapping.get_value(self.validater.data, "project_name", "")
         super().__init__(
             logger=logger,
             headers=self.headers,
@@ -57,10 +66,14 @@ class Veracode(FlatFileImporter):
         version = None
         # Veracode is a Web Application Security Scanner, so these will be software assets, scanning a
         # single web application
-        if "detailedreport" in self.mapping.mapping.keys():
-            name = self.mapping.get_value(dat, "detailedreport", {}).get(APP_NAME, "")
-            account_id = self.mapping.get_value(dat, "detailedreport", {}).get(ACCOUNT_ID, "")
-            version = self.mapping.get_value(dat, "detailedreport", {}).get(VERSION, "")
+        if "xml" in self.attributes.file_type:
+            detailed_report_data = dat.get("detailedreport", {})
+            name = detailed_report_data.get(APP_NAME, "")
+            account_id = detailed_report_data.get(ACCOUNT_ID, "")
+            version = detailed_report_data.get(VERSION, "")
+        elif "json" in self.attributes.file_type:
+            name = self.mapping.get_value(dat, "project_name", "")
+            account_id = self.asset_identifier
         else:
             name = self.mapping.get_value(dat, "Source", "")
             account_id = str(self.mapping.get_value(dat, "ID", ""))
@@ -88,7 +101,7 @@ class Veracode(FlatFileImporter):
         )
         return [asset]
 
-    def create_vuln(self, dat: Optional[dict] = None, **kwargs) -> List[Vulnerability]:
+    def create_vuln(self, dat: Optional[dict] = None, **kwargs) -> Union[List[Vulnerability], List[IntegrationFinding]]:
         """
         Create a RegScale vulnerability from a vulnerability in the Veracode export file
 
@@ -96,30 +109,62 @@ class Veracode(FlatFileImporter):
         :return: List of RegScale Vulnerability objects
         :rtype: List[Vulnerability]
         """
-        import_type = "xml" if isinstance(dat, str) else "csv"
         # Veracode is a Web Application Security Scanner, so these will be software assets,
         # scanning a single web application
-        if import_type == "xml":
-            name = self.mapping.get_value(dat, "detailedreport", {}).get(APP_NAME, "")
-            all_sev_data = self.mapping.get_value(dat, "detailedreport", {}).get("severity", [])
+        if "xml" in self.attributes.file_type:
+            detailed_report_data = dat.get("detailedreport", {})
+            name = detailed_report_data.get(APP_NAME, "")
+            all_sev_data = detailed_report_data.get("severity", [])
             severity = self.severity_info(all_sev_data)[0] if all_sev_data else "low"
             if severity_data := self.severity_info(all_sev_data):
-                if isinstance(severity_data, list) and len(severity_data) >= 2:
+                if isinstance(severity_data, tuple) and len(severity_data) >= 2:
                     cwes = [
-                        f"{c.get('cweid')} {c.get('cwename')}" for c in severity_data[1].get("cwe", [])
+                        f"{c.get('@cweid')} {c.get('@cwename')}" for c in severity_data[1].get("cwe", [])
                     ]  # Multiple cwes per asset in official XML
             else:
                 cwes = []
-        else:
+        elif "xlsx" in self.attributes.file_type:
             name = self.mapping.get_value(dat, "Source", "")
             severity = self.mapping.get_value(dat, "Sev", "").lower()
             cwes = [self.mapping.get_value(dat, "CWE ID & Name", [])]  # Coalfire should flatten data for asset -> cwes
+        elif "json" in self.attributes.file_type:
+            return self._parse_json_findings(**kwargs)
 
-        return self.process_csv_vulns(name, cwes, severity)
+        return self.process_vuln_data(name, cwes, severity)
 
-    def process_csv_vulns(self, hostname: str, cwes: List[str], severity: str) -> List[Vulnerability]:
+    def _parse_json_findings(self, **kwargs) -> List[IntegrationFinding]:
         """
-        Process the CSV findings from the ECR scan
+        Parse the JSON findings from the Veracode .json export file
+
+        :return: List of IntegrationFinding objects
+        :rtype: List[IntegrationFinding]
+        """
+        findings: List[IntegrationFinding] = []
+        for vuln in self.mapping.get_value(kwargs.get("data", self.validater.data), "findings", []):
+            if title := vuln.get("issue_type", vuln.get("title", "")):
+                findings.append(
+                    IntegrationFinding(
+                        title=title,
+                        description=vuln.get("display_text", "No description available"),
+                        severity=self.finding_severity_map.get(self.hit_mapping().get(vuln.get("severity", 0)), "Low"),
+                        status=IssueStatus.Open,
+                        plugin_name=vuln.get(title, self.name),
+                        plugin_id=vuln.get("cwe_id", vuln.get("issue_id", "")),
+                        plugin_text=vuln.get("issue_type", ""),
+                        asset_identifier=self.asset_identifier,
+                        first_seen=self.scan_date,
+                        last_seen=self.scan_date,
+                        scan_date=self.scan_date,
+                        category="Software",
+                        is_cwe=True,
+                        control_labels=[],
+                    )
+                )
+        return findings
+
+    def process_vuln_data(self, hostname: str, cwes: List[str], severity: str) -> List[Vulnerability]:
+        """
+        Process the vulnerability data to create a list of vulnerabilities
 
         :param str hostname: The hostname
         :param List[str] cwes: The CWEs
@@ -137,7 +182,7 @@ class Veracode(FlatFileImporter):
 
     def create_vulnerability_object(
         self, asset: Asset, hostname: str, cwe: str, severity: str, description: str
-    ) -> Vulnerability:
+    ) -> IntegrationFinding:
         """
         Create a vulnerability from a row in the Veracode file
 
@@ -146,33 +191,25 @@ class Veracode(FlatFileImporter):
         :param str cwe: The CWE
         :param str severity: The severity
         :param str description: The description
-        :return: The vulnerability
-        :rtype: Vulnerability
-        """
-        config = self.attributes.app.config
-
-        return Vulnerability(  # type: ignore
-            id=0,
-            scanId=0,
-            parentId=asset.id,
-            parentModule="assets",
-            ipAddress="0.0.0.0",
-            lastSeen=get_current_datetime(),  # No timestamp on Veracode
-            firstSeen=get_current_datetime(),  # No timestamp on Veracode
-            daysOpen=None,
-            dns=hostname,
-            mitigated=None,
-            operatingSystem=asset.operatingSystem,
-            severity=severity,
-            plugInName=cwe,
-            cve="",
-            tenantsId=0,
+        :return: The equivalent IntegrationFinding object
+        :rtype: IntegrationFinding
+        """
+        return IntegrationFinding(
             title=f"{cwe} on asset {asset.name}",
-            description=cwe,
-            plugInText=description,
-            createdById=config["userId"],
-            lastUpdatedById=config["userId"],
-            dateCreated=get_current_datetime(),
+            description=description,
+            status=IssueStatus.Open,
+            dns=hostname,
+            first_seen=self.scan_date,
+            last_seen=self.scan_date,
+            scan_date=self.scan_date,
+            category="Software",
+            is_cwe=True,
+            severity=self.finding_severity_map.get(self.hit_mapping().get(severity.title(), "Low")),
+            plugin_name=cwe,
+            plugin_id=cwe,
+            plugin_text=description,
+            asset_identifier=hostname,
+            control_labels=[],
         )
 
     def get_asset(self, hostname: str) -> Optional[Asset]:
@@ -214,4 +251,10 @@ class Veracode(FlatFileImporter):
             "2": "low",
             "1": "low",
             "0": "info",
+            5: "Critical",
+            4: "High",
+            3: "Medium",
+            2: "Low",
+            1: "Low",
+            0: "Low",
         }

regscale/models/regscale_models/control_implementation.py

@@ -212,8 +212,26 @@ class ControlImplementation(RegScaleModel):
             get_all_asset_controls_by_component="/api/{model_slug}/getAllAssetControlsByComponent/{int_id}",
             drilldown_asset_controls_by_component="/api/{model_slug}/drilldownAssetControlsByComponent/{component_id}/{str_field}/{str_value}",  # noqa: E501
             get_control_context="/api/{model_slug}/getControlContext/{int_control_id}/{int_parent_id}/{str_module}",
+            get_control_with_all_child_details="/api/{model_slug}/getControlWithAllChildDetails/{intId}",
         )
 
+    @classmethod
+    def get_with_child_details(cls, implementation_id: int) -> Optional[list[dict]]:
+        """
+        Get control implementation with all child details.
+
+        Retrieve a control implementation with all supporting data in a single call.
+
+        :param int implementation_id: The ID of the control implementation
+        :return: A list of control implementation details or None
+        :rtype: Optional[list[dict]]
+        """
+        endpoint = cls.get_endpoint("get_control_with_all_child_details").format(intId=implementation_id)
+        response = cls._get_api_handler().get(endpoint)
+        if response and response.ok:
+            return response.json()
+        return None
+
     def find_by_unique(self, **kwargs: dict) -> Optional["ControlImplementation"]:
         """
         Find an object by unique query.

regscale/models/regscale_models/control_objective.py

@@ -4,7 +4,7 @@
 from collections import defaultdict
 from typing import Any, Optional
 
-from pydantic import Field, ConfigDict
+from pydantic import ConfigDict, Field
 
 from regscale.core.app.utils.app_utils import get_current_datetime
 from regscale.models.regscale_models.regscale_model import RegScaleModel
@@ -25,6 +25,7 @@ class ControlObjective(RegScaleModel):
     otherId: str = ""  # API does not return if None
     archived: bool = False
     securityControlId: int
+    parentObjectiveId: Optional[int] = None
     dateCreated: str = Field(default_factory=get_current_datetime)
     dateLastUpdated: str = Field(default_factory=get_current_datetime)
     objectiveType: str = "objective"

regscale/models/regscale_models/facility.py

@@ -1,11 +1,9 @@
 """Facility model for RegScale."""
 
-import warnings
 from typing import Optional
-from urllib.parse import urljoin
 
-from regscale.core.app.api import Api
-from regscale.core.app.application import Application
+from pydantic import ConfigDict
+
 from regscale.models.regscale_models.regscale_model import RegScaleModel
 
 
@@ -32,28 +30,14 @@ class Facility(RegScaleModel):
     isPublic: bool = True
     dateLastUpdated: Optional[str] = None
 
-    def post(self, app: Application) -> Optional[dict]:
-        """Post a Facility to RegScale
+    @staticmethod
+    def _get_additional_endpoints() -> dict:
+        """
+        Get additional endpoints for the Facility model.
 
-        :param Application app: The application instance
-        :return: The response from the API or None
-        :rtype: Optional[dict]
+        :return: A dictionary of additional endpoints
+        :rtype: dict
         """
-        warnings.warn(
-            "The 'post' method is deprecated, use 'create' method instead",
-            DeprecationWarning,
-        )
-        api = Api()
-        url = urljoin(app.config.get("domain", ""), "/api/facilities")
-        data = self.dict()
-        response = api.post(url, json=data)
-        return response.json() if response.ok else None
-
-
-class Facilities(Facility):
-    def __init__(self, *args, **kwargs):
-        warnings.warn(
-            "The 'Facilities' class is deprecated, use 'Facility' instead",
-            DeprecationWarning,
+        return ConfigDict(
+            get_list="/api/{model_slug}/get_list",
         )
-        super().__init__(*args, **kwargs)

regscale/models/regscale_models/functional_roles.py

@@ -0,0 +1,38 @@
+from typing import List
+
+from pydantic import ConfigDict
+
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class FunctionalRole(RegScaleModel):
+    """
+    Functional Role Model
+    """
+
+    _module_slug = "functionalroles"
+
+    id: int = 0
+    role: str
+
+    @classmethod
+    def get_list(cls) -> List["FunctionalRole"]:
+        """
+        Get list of Functional Roles
+
+        :return: list of Functional Roles
+        :rtype: List["FunctionalRole"]
+        """
+        return cls._handle_list_response(cls._get_api_handler().get(cls.get_endpoint("get_list")))
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the FunctionalRole
+
+        :return: Additional endpoints for the FunctionalRole
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_list="/api/{model_slug}/getList",
+        )

regscale/models/regscale_models/issue.py

@@ -788,7 +788,9 @@ class Issue(RegScaleModel):
         take = 50
         skip = 0
         control_issues: Dict[int, List[OpenIssueDict]] = defaultdict(list)
-        logger.info("Fetching open issues for controls and for security plan %i...", plan_id)
+        logger.info(
+            f"Fetching open issues for controls and for security plan {plan_id}...",
+        )
         supports_multiple_controls: bool = cls.is_multiple_controls_supported()
 
         # Define fields based on version

regscale/models/regscale_models/parameter.py

@@ -3,10 +3,9 @@
 """Regscale Model for Implementation Parameter in the application"""
 
 from enum import Enum
-from typing import Optional, List
+from typing import List, Optional
 
-from pydantic import ConfigDict
-from pydantic import Field
+from pydantic import ConfigDict, Field
 
 from regscale.core.app.utils.app_utils import get_current_datetime
 from regscale.models.regscale_models.regscale_model import RegScaleModel
@@ -85,3 +84,22 @@ class Parameter(RegScaleModel):
         if response and response.ok:
             return [Parameter(**param) for param in response.json()]
         return []
+
+    @classmethod
+    def merge_parameters(cls, implementation_id: int, security_control_id: int) -> List["Parameter"]:
+        """
+        Get a list of parameters by implementation ID and security control ID.
+
+        :param int implementation_id: The ID of the controlImplementation
+        :param int security_control_id: The ID of the security control
+        :return: A list of parameters
+        :rtype: List["Parameter"]
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("merge").format(
+                implementationID=implementation_id, securityControlID=security_control_id
+            )
+        )
+        if response and response.ok:
+            return [cls(**ci) for ci in response.json()]
+        return []

regscale/models/regscale_models/profile.py

@@ -30,6 +30,28 @@ class Profile(RegScaleModel):
     confidentiality: Optional[str] = None
     integrity: Optional[str] = None
 
+    @classmethod
+    def apply_profile(cls, module_id: int, module_name: str, profile_id: int, is_public: bool) -> bool:
+        """
+        Apply a profile to a module.
+
+        :param int module_id: The module ID
+        :param str module_name: The module name
+        :param int profile_id: The profile ID
+        :param bool is_public: Whether the profile is public
+        :return: True if the profile was applied
+        :rtype: bool
+        """
+        endpoint = cls.get_endpoint("apply_profile").format(
+            model_slug=cls._module_slug,
+            moduleId=module_id,
+            moduleName=module_name,
+            profileId=profile_id,
+            isPublic=is_public,
+        )
+        response = cls._get_api_handler().post(endpoint)
+        return response.ok
+
     @staticmethod
     def _get_additional_endpoints() -> ConfigDict:
         """

regscale/models/regscale_models/profile_mapping.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """Model for Profile Mapping in the application"""
-from typing import List, Optional
+import importlib
+from typing import TYPE_CHECKING, List, Optional
 from urllib.parse import urljoin
 
 from pydantic import ConfigDict, Field
@@ -11,6 +12,9 @@ from regscale.core.app.application import Application
 from regscale.models.regscale_models.regscale_model import RegScaleModel
 from regscale.models.regscale_models.security_control import SecurityControl
 
+if TYPE_CHECKING:
+    from regscale.models import ControlImplementation, ControlImplementationStatus
+
 
 class ProfileMapping(RegScaleModel):
     """
@@ -33,6 +37,41 @@ class ProfileMapping(RegScaleModel):
     isPublic: bool = True
     lastUpdatedById: Optional[str] = None
 
+    def __init__(self, **data):
+        super().__init__(**data)
+
+    # Create a lazily loaded reference to avoid circular imports
+    def _get_control_implementation_classes(self):
+        """
+        Get the control implementation classes in a lazy manner
+
+        :return: The control implementation classes
+        :rtype: Tuple[ControlImplementation, ControlImplementationStatus]
+        :raises ImportError: If the module cannot be imported
+        """
+        module = importlib.import_module("regscale.models")
+        return (module.ControlImplementation, module.ControlImplementationStatus)
+
+    def to_implementation(self, security_plan_id: int):
+        """
+        Convert a profile mapping to a control implementation.
+
+        :param int security_plan_id: The parent Security Plan ID
+        :rtype: ControlImplementation
+        :return: The control implementation
+        """
+        # Create a lazily loaded reference to avoid circular imports, will only import once, and subsequent calls will
+        # use the already imported classes
+        ControlImplementation, ControlImplementationStatus = self._get_control_implementation_classes()
+
+        return ControlImplementation(
+            status=ControlImplementationStatus.NotImplemented.value,
+            controlID=self.controlID,
+            assessmentFrequency=365,
+            parentId=security_plan_id,
+            parentModule="securityplans",
+        )
+
     @staticmethod
     def _get_additional_endpoints() -> ConfigDict:
         """
@@ -62,14 +101,20 @@ class ProfileMapping(RegScaleModel):
         :return: List of profile mappings
         :rtype: List[ProfileMapping]
         """
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
         response = cls._get_api_handler().get(
             endpoint=cls.get_endpoint("get_by_profile").format(intProfileID=profile_id)
         )
         mappings = []
         if response and response.ok:
             mappings = [cls(**map) for map in response.json()]
-            for mapping in mappings:
-                if control := SecurityControl.get_object(object_id=mapping.controlID):
+            with ThreadPoolExecutor() as executor:
+                futures = [
+                    executor.submit(SecurityControl.get_object, object_id=mapping.controlID) for mapping in mappings
+                ]
+            for future, mapping in zip(as_completed(futures), mappings):
+                if control := future.result():
                     mapping.control = control
         return mappings
 

regscale/models/regscale_models/regscale_model.py

@@ -1315,6 +1315,7 @@ class RegScaleModel(BaseModel, ABC):
             :param Optional[Progress] progress: Optional progress context for tracking
             :param Optional[bool] remove_progress_bar: Whether to remove the progress bar after completion, defaults to False
             """
+            # noqa: F824
             nonlocal results
             create_job = None
             if progress:
@@ -1372,6 +1373,7 @@ class RegScaleModel(BaseModel, ABC):
             :param Optional[Progress] progress: Optional progress context for tracking
             :param Optional[bool] remove_progress_bar: Whether to remove the progress bar after completion, defaults to False
             """
+            # noqa: F824
             nonlocal results
             update_job = None
             if progress: