regscale-cli 6.27.2.0__py3-none-any.whl → 6.27.3.0__py3-none-any.whl

regscale/models/integration_models/synqly_models/connectors/vulnerabilities.py

@@ -82,6 +82,30 @@ class Vulnerabilities(SynqlyModel):
         severity_filter = f"severity[in]{','.join(mapped_severities)}"
         return severity_filter
 
+    @staticmethod
+    def _translate_asset_filter(replace: str, replace_with: str, asset_filters: Optional[list[str]]) -> list[str]:
+        """
+        Translate asset filters to the correct format for the integration
+
+        :param str replace: The string to replace
+        :param str replace_with: The string to replace with
+        :param list[str] asset_filters: The asset filters to translate
+        :return: The translated asset filters
+        :rtype: list[str]
+        """
+        translated_asset_filters = []
+        for asset_filter in asset_filters:
+            # Remove outer double quotes if present
+            cleaned_filter = asset_filter
+            if cleaned_filter.startswith('"') and cleaned_filter.endswith('"') and len(cleaned_filter) > 1:
+                cleaned_filter = cleaned_filter[1:-1]
+
+            if replace_with in cleaned_filter:
+                translated_asset_filters.append(cleaned_filter)
+            elif replace in cleaned_filter:
+                translated_asset_filters.append(cleaned_filter.replace(replace, replace_with))
+        return translated_asset_filters
+
     def _handle_scan_date_options(self, regscale_ssp_id: int, **kwargs) -> list[str]:
         """
         Handle scan date options for the integration sync process
@@ -94,6 +118,13 @@ class Vulnerabilities(SynqlyModel):
 
         vuln_filter = [self._build_severity_filter(kwargs.get("minimum_severity_filter"))]
 
+        if asset_filters := kwargs.get("filter", []):
+            vuln_filter.extend(
+                self._translate_asset_filter(
+                    replace="device.", replace_with="resources.data.", asset_filters=asset_filters
+                )
+            )
+
         if kwargs.get("all_scans"):
             vuln_filter.append("finding.last_seen_time[gte]915148800")  # Friday, January 1, 1999 12:00:00 AM UTC
         elif scan_date := kwargs.get("scan_date"):
@@ -118,8 +149,10 @@ class Vulnerabilities(SynqlyModel):
         self.logger.debug(f"Vulnerability filter: {vuln_filter}")
 
         # Pop the filter from kwargs so it doesn't get passed to query_findings
-        asset_filter = kwargs.pop("filter", [])
-        if asset_filter:
+        if asset_filter := kwargs.pop("filter", []):
+            asset_filter = self._translate_asset_filter(
+                replace="resources.data.", replace_with="device.", asset_filters=asset_filter
+            )
             self.logger.debug(f"Asset filter: {asset_filter}")
 
         self.logger.info(f"Fetching asset data from {self.integration_name}...")

regscale/models/integration_models/synqly_models/ocsf_mapper.py

@@ -106,9 +106,8 @@ class Mapper:
             regscale_issue.manualDetectionId = ticket.id
         return regscale_issue
 
-    @staticmethod
     def _ocsf_asset_to_regscale(
-        connector: Union["Edr", "Vulnerabilities"], asset: Union[InventoryInfo, OCSFAsset, SoftwareInfo], **kwargs
+        self, connector: Union["Edr", "Vulnerabilities"], asset: Union[InventoryInfo, OCSFAsset, SoftwareInfo], **kwargs
     ) -> IntegrationAsset:
         """
         Convert OCSF Asset to RegScale Asset
@@ -134,6 +133,9 @@ class Mapper:
         else:
             name = device_data.name or device_data.hostname or f"{connector.provider} Asset: {device_data.uid}"
             category = AssetCategory.Software
+        ip_v4s, ip_v6s = self._determine_ip_addresses(
+            device_data.ip_addresses if device_data.ip_addresses else [device_data.ip]
+        )
         return IntegrationAsset(
             name=name,
             identifier=device_data.uid,
@@ -143,7 +145,8 @@ class Mapper:
             parent_module=SecurityPlan.get_module_string(),
             mac_address=device_data.mac,
             fqdn=device_data.hostname,
-            ip_address=", ".join(device_data.ip_addresses) if device_data.ip_addresses else device_data.ip,
+            ip_address=", ".join(ip_v4s),
+            ipv6_address=", ".join(ip_v6s),
             location=device_data.location or device_data.zone,
             vlan_id=device_data.vlan_uid,
             other_tracking_number=device_data.uid,
@@ -155,6 +158,31 @@ class Mapper:
             software_inventory=software_inventory,
         )
 
+    @staticmethod
+    def _determine_ip_addresses(ips: list[str]) -> tuple[list[str], list[str]]:
+        """
+        Parse the list of ips and return a tuple of two lists: list of IP v4 and IP v6 addresses
+
+        :param list[str] ips: List of IP addresses
+        :return: Tuple containing two lists, list of IP v4 addresses and list of IP v6 addresses
+        :rtype: tuple[list[str], list[str]]
+        """
+        import ipaddress
+
+        ip_v4s = []
+        ip_v6s = []
+        for ip in ips:
+            try:
+                ipaddress.IPv4Address(ip)
+                ip_v4s.append(ip)
+            except ipaddress.AddressValueError:
+                try:
+                    ipaddress.IPv6Address(ip)
+                    ip_v6s.append(ip)
+                except ipaddress.AddressValueError:
+                    continue
+        return ip_v4s, ip_v6s
+
     @staticmethod
     def _determine_date(
         attribute: str, finding: Optional["Finding"] = None, vuln: Optional["Vulnerability"] = None
@@ -205,6 +233,7 @@ class Mapper:
             "plugin_id": vuln.cve.uid if vuln else finding.finding.product_uid,
             "severity": vuln.severity if vuln and getattr(vuln, "severity") else finding.severity_id,
             "remediation": getattr(vuln, "remediation") if vuln else finding.finding.remediation.desc,
+            "title": getattr(vuln, "title") or finding.finding.title,
         }
         if vuln:
             finding_data["cve"] = vuln.cve.uid
@@ -267,28 +296,28 @@ class Mapper:
             """
             base = vuln if vuln else finding.finding
             finding_data = self._parse_finding_data(finding, vuln)
-            if resource_data := getattr(resource, "data"):
-                dns = resource_data.get("hostname")
-                ip_address = resource_data.get("ipv4")
-            else:
-                dns = resource.uid if vuln else None
-                ip_address = None
+            resource_data = getattr(resource, "data", {})
+            dns = resource_data.get("hostname") or resource.uid if vuln else None
+            ip_v4s, ip_v6s = self._determine_ip_addresses(
+                resource_data["ipAddresses"] if resource_data.get("ipAddresses") else [resource_data.get("ip")]
+            )
+            ips = ip_v4s + ip_v6s
 
             finding_obj = IntegrationFinding(
                 control_labels=[],
                 category=f"{connector.integration_name} Vulnerability",
-                title=base.title,
+                title=finding_data["title"],
                 plugin_name=connector.integration_name,
                 severity=Issue.assign_severity(finding.severity),  # type: ignore
                 description=base.desc,
                 status=finding.status or "Open",
                 first_seen=self._datetime_to_str(finding_data["first_seen"]),
                 last_seen=self._datetime_to_str(finding_data["last_seen"]),
-                ip_address=ip_address,
+                ip_address=", ".join(ips),
                 plugin_id=finding_data["plugin_id"],
                 dns=dns,
                 severity_int=finding_data["severity"],
-                issue_title=base.title,
+                issue_title=finding_data["title"],
                 cve=finding_data["cve"],
                 evidence=finding.evidence,
                 impact=finding.impact,

regscale/models/platform.py

@@ -44,6 +44,7 @@ class RegScaleAuth(BaseModel):
         password: Optional[Union[str, SecretStr]] = None,
         domain: Optional[str] = None,
         mfa_token: Optional[str] = None,
+        app_id: Optional[int] = 1,
     ) -> "RegScaleAuth":
         """
         Authenticate with RegScale and return a token and a user_id
@@ -52,6 +53,7 @@ class RegScaleAuth(BaseModel):
         :param Optional[Union[str, SecretStr]] password: Password to log in with, defaults to None
         :param Optional[str] domain: Domain to log into, defaults to None
         :param Optional[str] mfa_token: mfa_token to verify, defaults to None
+        :param Optional[int] app_id: The app ID to login with
         :return: RegScaleAuth object
         :rtype: RegScaleAuth
         """
@@ -88,6 +90,7 @@ class RegScaleAuth(BaseModel):
             password=password.get_secret_value(),
             domain=domain,
             mfa_token=mfa_token,
+            app_id=app_id,
         )
         return cls(
             user_id=uid,

regscale/models/regscale_models/__init__.py

@@ -51,6 +51,8 @@ from .link import *
 from .master_assessment import *
 from .milestone import *
 from .meta_data import *
+from .module import *
+from .modules import *
 from .objective import *
 from .organization import *
 from .parameter import *
@@ -81,10 +83,13 @@ from .stig import *
 from .supply_chain import *
 from .system_role import *
 from .system_role_external_assignment import *
+from .tag import *
+from .tag_mapping import *
 from .task import *
 from .threat import *
 from .team import *
 from .user import *
+from .user_group import *
 from .vulnerability import *
 from .vulnerability_mapping import *
 from .workflow import *

regscale/models/regscale_models/component.py

@@ -76,7 +76,7 @@ class Component(RegScaleModel):
     externalId: Optional[str] = None
     isPublic: bool = True
     riskCategorization: Optional[str] = None
-    complianceSettingsId: Optional[int] = None
+    complianceSettingsId: Optional[int] = 1
 
     @staticmethod
     def _get_additional_endpoints() -> ConfigDict:

regscale/models/regscale_models/control_implementation.py

@@ -489,15 +489,15 @@ class ControlImplementation(RegScaleModel):
         :return: A dictionary mapping control IDs to implementation IDs
         :rtype: Dict[str, int]
         """
-        logger.info("Getting control label map by parent...")
+        logger.debug("Getting control label map by parent...")
         response = cls._get_api_handler().get(
             endpoint=cls.get_endpoint("get_all_by_parent").format(intParentID=parent_id, strModule=parent_module)
         )
 
         if response and response.ok:
-            logger.info("Fetched control label map by parent successfully.")
+            logger.debug("Fetched control label map by parent successfully.")
             return {parentheses_to_dot(ci["controlName"]): ci["id"] for ci in response.json()}
-        logger.info("Unable to get control label map by parent.")
+        logger.debug("Unable to get control label map by parent.")
         return {}
 
     @classmethod
@@ -509,14 +509,14 @@ class ControlImplementation(RegScaleModel):
         :return: A dictionary mapping control IDs to implementation IDs
         :rtype: Dict[int, int]
         """
-        logger.info("Getting control id map by parent...")
+        logger.debug("Getting control id map by parent...")
         response = cls._get_api_handler().get(
             endpoint=cls.get_endpoint("get_all_by_parent").format(intParentID=parent_id, strModule=parent_module)
         )
         if response and response.ok:
-            logger.info("Fetched control id map by parent successfully.")
+            logger.debug("Fetched control id map by parent successfully.")
             return {ci["controlID"]: ci["id"] for ci in response.json()}
-        logger.info("Unable to get control id map by parent.")
+        logger.debug("Unable to get control id map by parent.")
         return {}
 
     @classmethod
@@ -1218,6 +1218,8 @@ class ControlImplementation(RegScaleModel):
         :return: list GraphQL response from RegScale
         :rtype: list
         """
+        from regscale.core.app.internal.control_editor import _extract_control_owner_display
+
         body = """
                     query{
                         controlImplementations (skip: 0, take: 50, where: {parentId: {eq: parent_id} parentModule: {eq: "parent_module"}}) {
@@ -1263,22 +1265,25 @@ class ControlImplementation(RegScaleModel):
                 moded_item = {}
                 moded_item["id"] = item["id"]
                 moded_item["controlID"] = item["controlID"]
-                moded_item["controlOwnerId"] = (
-                    str(item["controlOwner"]["lastName"]).strip()
-                    + ", "
-                    + str(item["controlOwner"]["firstName"]).strip()
-                    + " ("
-                    + str(item["controlOwner"]["userName"]).strip()
-                    + ")"
-                )
-                moded_item["controlName"] = item["control"]["controlId"]
-                moded_item["controlTitle"] = item["control"]["title"]
-                moded_item["description"] = item["control"]["description"]
-                moded_item["status"] = item["status"]
-                moded_item["policy"] = item["policy"]
-                moded_item["implementation"] = item["implementation"]
-                moded_item["responsibility"] = item["responsibility"]
-                moded_item["inheritable"] = item["inheritable"]
+
+                # Extract control owner display using centralized method
+                moded_item["controlOwnerId"] = _extract_control_owner_display(item)
+
+                # Handle case where control or its fields might be None
+                if item.get("control") and item["control"] is not None:
+                    moded_item["controlName"] = item["control"].get("controlId", "")
+                    moded_item["controlTitle"] = item["control"].get("title", "")
+                    moded_item["description"] = item["control"].get("description", "")
+                else:
+                    moded_item["controlName"] = ""
+                    moded_item["controlTitle"] = ""
+                    moded_item["description"] = ""
+
+                moded_item["status"] = item.get("status", "")
+                moded_item["policy"] = item.get("policy", "")
+                moded_item["implementation"] = item.get("implementation", "")
+                moded_item["responsibility"] = item.get("responsibility", "")
+                moded_item["inheritable"] = item.get("inheritable", False)
                 moded_data.append(moded_item)
             return moded_data
         return []
@@ -1351,8 +1356,34 @@ class ControlImplementation(RegScaleModel):
         :return: list of control implementations, or None if not found
         :rtype: Optional[list[dict]]
         """
-        endpoint = cls.get_endpoint("get_list_by_parent").format(int_id=regscale_id, str_module=regscale_module)
-        response = cls._get_api_handler().get(endpoint=endpoint)
+        query = {
+            "parentID": 0,
+            "module": "",
+            "friendlyName": "",
+            "workbench": "",
+            "base": "",
+            "sort": "sortId",
+            "direction": "Ascending",
+            "simpleSearch": "",
+            "page": 1,
+            "pageSize": 1000,
+            "query": {
+                "id": 0,
+                "viewName": "",
+                "module": "",
+                "scope": "",
+                "createdById": "",
+                "dateCreated": None,
+                "parameters": [],
+            },
+            "groupBy": "",
+            "intDays": 0,
+            "subTab": True,
+        }
+        query["parentId"] = regscale_id
+        query["module"] = regscale_module
+        endpoint = cls.get_endpoint("filter_control_implementations")
+        response = cls._get_api_handler().post(endpoint=endpoint, data=query)
         if response and response.ok:
             return response.json()
         return None

regscale/models/regscale_models/organization.py

@@ -15,7 +15,10 @@ class Organization(RegScaleModel):
     id: int = 0
     name: Optional[str] = ""
     description: Optional[str] = ""
+    orgCode: Optional[str] = ""
+    orgUrl: Optional[str] = ""
     status: Optional[str] = "Active"
+    externalId: Optional[str] = ""
 
     @staticmethod
     def _get_additional_endpoints() -> dict:

regscale/models/regscale_models/regscale_model.py

@@ -1258,17 +1258,18 @@ class RegScaleModel(BaseModel, ABC):
         return ConfigDict()
 
     @classmethod
-    def get_endpoint(cls, endpoint_type: str) -> str:
+    def get_endpoint(cls, endpoint_type: str, suppress_error: bool = False) -> str:
         """
         Get the endpoint for a specific type.
 
         :param str endpoint_type: The type of endpoint
+        :param bool suppress_error: Whether to suppress the error if the endpoint is not found, defaults to False
         :raises ValueError: If the endpoint type is not found
         :return: The endpoint
         :rtype: str
         """
         endpoint = cls._get_endpoints().get(endpoint_type, "na")  # noqa
-        if not endpoint or endpoint == "na":
+        if not endpoint or endpoint == "na" and not suppress_error:
             logger.error(f"{cls.__name__} does not have endpoint {endpoint_type}")
             raise ValueError(f"Endpoint {endpoint_type} not found")
         endpoint = str(endpoint).replace("{model_slug}", cls.get_module_slug())
@@ -1566,11 +1567,22 @@ class RegScaleModel(BaseModel, ABC):
                     f"[#f68d1f]Updating {total_items} RegScale {cls.__name__}s...",
                     total=total_items,
                 )
+            endpoint = cls.get_endpoint("batch_update", suppress_error=True)
+            if not endpoint or endpoint == "na":
+                logger.debug(f"No batch_update endpoint found for {cls.__name__}, using save method instead")
+                for item in items:
+                    updated_item = item.save()
+                    cls.cache_object(updated_item)
+                    results.append(updated_item)
+                    if progress and update_job is not None:
+                        progress.advance(update_job, advance=1)
+                cls._check_and_remove_progress_object(progress_context, remove_progress_bar, update_job)
+                return results
             for i in range(0, total_items, batch_size):
                 batch = items[i : i + batch_size]
                 batch_results = cls._handle_list_response(
                     cls._get_api_handler().put(
-                        endpoint=cls.get_endpoint("batch_update"),
+                        endpoint=endpoint,
                         data=[item.model_dump() for item in batch if item],
                     )
                 )
@@ -1583,10 +1595,10 @@ class RegScaleModel(BaseModel, ABC):
             cls._check_and_remove_progress_object(progress_context, remove_progress_bar, update_job)
 
         if progress_context:
-            process_batch(progress_context)
+            process_batch(progress=progress_context, remove_progress_bar=remove_progress)
         else:
             with create_progress_object() as create_progress:
-                process_batch(create_progress)
+                process_batch(progress=create_progress, remove_progress_bar=remove_progress)
 
         return results
 

regscale/models/regscale_models/security_plan.py

@@ -43,6 +43,7 @@ class SecurityPlan(RegScaleModel):
     environment: Optional[str] = ""
     lawsAndRegulations: Optional[str] = ""
     authorizationBoundary: Optional[str] = ""
+    authorizationTerminationDate: Optional[str] = ""
     networkArchitecture: Optional[str] = ""
     dataFlow: Optional[str] = ""
     overallCategorization: Optional[str] = ""

regscale/regscale.py

@@ -477,12 +477,21 @@ def validate_token():
     cls=NotRequiredIf,
     not_required_if=["token"],
 )
+@click.option(
+    "--app_id",
+    type=click.INT,
+    help="RegScale App ID to login with.",
+    default=1,
+    prompt=False,
+    required=False,
+)
 def login(
     username: Optional[str],
     password: Optional[str],
     token: Optional[str] = None,
     domain: Optional[str] = None,
     mfa_token: Optional[str] = None,
+    app_id: Optional[int] = 1,
 ):
     """Logs the user into their RegScale instance."""
     from regscale.core.app.application import Application
@@ -502,9 +511,10 @@ def login(
             mfa_token=mfa_token,
             app=app,
             host=domain,
+            app_id=app_id,
         )
     else:
-        lg.login(str_user=username, str_password=password, app=app, host=domain)
+        lg.login(str_user=username, str_password=password, app=app, host=domain, app_id=app_id)
 
 
 # Check the health of the RegScale Application

{regscale_cli-6.27.2.0.dist-info → regscale_cli-6.27.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: regscale-cli
-Version: 6.27.2.0
+Version: 6.27.3.0
 Summary: Command Line Interface (CLI) for bulk processing/loading data into RegScale
 Home-page: https://github.com/RegScale/regscale-cli
 Author: Travis Howerton