regscale-cli 6.21.2.0__py3-none-any.whl → 6.28.2.1__py3-none-any.whl

regscale/integrations/commercial/qualys/__init__.py

@@ -34,9 +34,8 @@ from regscale.integrations.commercial.qualys.scanner import QualysTotalCloudJSON
 from regscale.integrations.commercial.qualys.variables import QualysVariables
 from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding
 from regscale.integrations.variables import ScannerVariables
-from regscale.models import Asset, Issue, Search, regscale_models
-from regscale.models.app_models.click import NotRequiredIf, regscale_ssp_id, save_output_to, ssp_or_component_id
-from regscale.models.integration_models.ecr_models.data import Finding
+from regscale.models import Asset, Issue, Search, regscale_models, IssueStatus, IssueSeverity
+from regscale.models.app_models.click import NotRequiredIf, save_output_to, ssp_or_component_id
 from regscale.models.integration_models.flat_file_importer import FlatFileImporter
 from regscale.models.integration_models.qualys import (
     Qualys,
@@ -280,7 +279,7 @@ class FindingProgressTracker:
         try:
             finding = next(self.findings_iter)
             self.count += 1
-            if finding and hasattr(finding, "external_id"):
+            if finding and hasattr(finding, "external_id") and finding.external_id is not None:
                 self.finding_ids.append(finding.external_id)
             self.progress.update(self.finding_task, advance=1)
             return finding
@@ -378,6 +377,11 @@ def import_total_cloud(
     if exclude_tags and not include_tags:
         error_and_exit("You must provide --include_tags when using --exclude_tags to import Qualys Total Cloud data.")
 
+    # Ensure vulnerability creation is properly set
+    if not vulnerability_creation:
+        vulnerability_creation = "IssueCreation"  # Default to IssueCreation for Qualys
+        logger.info("No vulnerability creation setting provided, defaulting to IssueCreation for Qualys Total Cloud")
+
     containers_lst = []
     try:
         # Configure scanner variables and fetch data
@@ -1631,26 +1635,12 @@ def sync_assets(
     """
     parent_module = "components" if is_component else "securityplans"
     update_assets = []
-    for qualys_asset in qualys_assets:  # you can list as many input dicts as you want here
-        logger.debug("qualys_asset: %s", qualys_asset)
-        if not isinstance(qualys_asset, dict):
-            logger.error("Expected dict, got %s: %s", type(qualys_asset), qualys_asset)
-            continue
-        # Update parent id to SSP or Component on insert
-        if lookup_assets := lookup_asset(reg_assets, qualys_asset["ASSET_ID"]):
-            for asset in set(lookup_assets):
-                asset.parentId = ssp_id
-                asset.parentModule = parent_module
-                asset.otherTrackingNumber = qualys_asset["ID"]
-                asset.ipAddress = qualys_asset["IP"]
-                asset.qualysId = qualys_asset["ASSET_ID"]
-                try:
-                    assert asset.id
-                    # avoid duplication
-                    if asset.qualysId not in [v["qualysId"] for v in update_assets]:
-                        update_assets.append(asset)
-                except AssertionError as aex:
-                    logger.error("Asset does not have an id, unable to update!\n%s", aex)
+
+    for qualys_asset in qualys_assets:
+        processed_asset = _process_single_qualys_asset(qualys_asset, reg_assets, ssp_id, parent_module)
+        if processed_asset:
+            update_assets.append(processed_asset)
+
     update_and_insert_assets(
         qualys_assets=qualys_assets,
         reg_assets=reg_assets,
@@ -1661,6 +1651,57 @@ def sync_assets(
     )
 
 
+def _process_single_qualys_asset(
+    qualys_asset: dict, reg_assets: list[Asset], ssp_id: int, parent_module: str
+) -> Optional[Asset]:
+    """
+    Process a single Qualys asset and return the updated RegScale asset if found.
+
+    :param dict qualys_asset: Single Qualys asset dictionary
+    :param list[Asset] reg_assets: List of RegScale assets
+    :param int ssp_id: RegScale System Security Plan or Component ID
+    :param str parent_module: Parent module name
+    :return: Updated RegScale asset or None if not found
+    :rtype: Optional[Asset]
+    """
+    logger.debug("qualys_asset: %s", qualys_asset)
+
+    if not isinstance(qualys_asset, dict):
+        logger.error("Expected dict, got %s: %s", type(qualys_asset), qualys_asset)
+        return None
+
+    lookup_assets = lookup_asset(reg_assets, qualys_asset["ASSET_ID"])
+    if not lookup_assets:
+        return None
+
+    return _update_regscale_asset(lookup_assets[0], qualys_asset, ssp_id, parent_module)
+
+
+def _update_regscale_asset(asset: Asset, qualys_asset: dict, ssp_id: int, parent_module: str) -> Optional[Asset]:
+    """
+    Update a RegScale asset with Qualys asset data.
+
+    :param Asset asset: RegScale asset to update
+    :param dict qualys_asset: Qualys asset data
+    :param int ssp_id: RegScale System Security Plan or Component ID
+    :param str parent_module: Parent module name
+    :return: Updated asset or None if update failed
+    :rtype: Optional[Asset]
+    """
+    try:
+        asset.parentId = ssp_id
+        asset.parentModule = parent_module
+        asset.otherTrackingNumber = qualys_asset["ID"]
+        asset.ipAddress = qualys_asset["IP"]
+        asset.qualysId = qualys_asset["ASSET_ID"]
+
+        assert asset.id
+        return asset
+    except AssertionError as aex:
+        logger.error("Asset does not have an id, unable to update!\n%s", aex)
+        return None
+
+
 def update_and_insert_assets(
     qualys_assets: list[dict],
     reg_assets: list[Asset],
@@ -1681,48 +1722,106 @@ def update_and_insert_assets(
     :rtype: None
     """
     parent_module = "components" if is_component else "securityplans"
-    insert_assets = []
-    if assets_to_be_inserted := [
+
+    # Handle asset insertion
+    insert_assets = _prepare_assets_for_insertion(qualys_assets, reg_assets, ssp_id, parent_module, config)
+    if insert_assets:
+        _create_assets_in_batch(insert_assets)
+
+    # Handle asset updates
+    if update_assets:
+        _update_assets_in_batch(update_assets)
+
+
+def _prepare_assets_for_insertion(
+    qualys_assets: list[dict], reg_assets: list[Asset], ssp_id: int, parent_module: str, config: dict
+) -> list[Asset]:
+    """
+    Prepare new assets for insertion into RegScale.
+
+    :param list[dict] qualys_assets: List of Qualys assets
+    :param list[Asset] reg_assets: List of RegScale assets
+    :param int ssp_id: RegScale System Security Plan or Component ID
+    :param str parent_module: Parent module name
+    :param dict config: Configuration dictionary
+    :return: List of assets to insert
+    :rtype: list[Asset]
+    """
+    assets_to_be_inserted = [
         qualys_asset
         for qualys_asset in qualys_assets
         if qualys_asset["ASSET_ID"] not in [asset["ASSET_ID"] for asset in inner_join(reg_assets, qualys_assets)]
-    ]:
-        for qualys_asset in assets_to_be_inserted:
-            # Do Insert
-            r_asset = Asset(
-                name=f'Qualys Asset #{qualys_asset["ASSET_ID"]} IP: {qualys_asset["IP"]}',
-                otherTrackingNumber=qualys_asset["ID"],
-                parentId=ssp_id,
-                parentModule=parent_module,
-                ipAddress=qualys_asset["IP"],
-                assetOwnerId=config["userId"],
-                assetType="Other",
-                assetCategory=regscale_models.AssetCategory.Hardware,
-                status="Off-Network",
-                qualysId=qualys_asset["ASSET_ID"],
-            )
-            # avoid duplication
-            if r_asset.qualysId not in {v["qualysId"] for v in insert_assets}:
-                insert_assets.append(r_asset)
-        try:
-            created_assets = Asset.batch_create(insert_assets, job_progress)
-            logger.info(
-                "RegScale Asset(s) successfully created: %i/%i",
-                len(created_assets),
-                len(insert_assets),
-            )
-        except requests.exceptions.RequestException as rex:
-            logger.error("Unable to create Qualys Assets in RegScale\n%s", rex)
-    if update_assets:
-        try:
-            updated_assets = Asset.batch_update(update_assets, job_progress)
-            logger.info(
-                "RegScale Asset(s) successfully updated: %i/%i",
-                len(updated_assets),
-                len(update_assets),
-            )
-        except requests.RequestException as rex:
-            logger.error("Unable to Update Qualys Assets to RegScale\n%s", rex)
+    ]
+
+    insert_assets = []
+    for qualys_asset in assets_to_be_inserted:
+        r_asset = _create_regscale_asset_from_qualys(qualys_asset, ssp_id, parent_module, config)
+        # avoid duplication
+        if r_asset.qualysId not in {v["qualysId"] for v in insert_assets}:
+            insert_assets.append(r_asset)
+
+    return insert_assets
+
+
+def _create_regscale_asset_from_qualys(qualys_asset: dict, ssp_id: int, parent_module: str, config: dict) -> Asset:
+    """
+    Create a RegScale asset from Qualys asset data.
+
+    :param dict qualys_asset: Qualys asset data
+    :param int ssp_id: RegScale System Security Plan or Component ID
+    :param str parent_module: Parent module name
+    :param dict config: Configuration dictionary
+    :return: New RegScale asset
+    :rtype: Asset
+    """
+    return Asset(
+        name=f'Qualys Asset #{qualys_asset["ASSET_ID"]} IP: {qualys_asset["IP"]}',
+        otherTrackingNumber=qualys_asset["ID"],
+        parentId=ssp_id,
+        parentModule=parent_module,
+        ipAddress=qualys_asset["IP"],
+        assetOwnerId=config["userId"],
+        assetType="Other",
+        assetCategory=regscale_models.AssetCategory.Hardware,
+        status="Off-Network",
+        qualysId=qualys_asset["ASSET_ID"],
+    )
+
+
+def _create_assets_in_batch(insert_assets: list[Asset]) -> None:
+    """
+    Create assets in batch and handle any errors.
+
+    :param list[Asset] insert_assets: List of assets to create
+    :rtype: None
+    """
+    try:
+        created_assets = Asset.batch_create(insert_assets, job_progress)
+        logger.info(
+            "RegScale Asset(s) successfully created: %i/%i",
+            len(created_assets),
+            len(insert_assets),
+        )
+    except requests.exceptions.RequestException as rex:
+        logger.error("Unable to create Qualys Assets in RegScale\n%s", rex)
+
+
+def _update_assets_in_batch(update_assets: list[Asset]) -> None:
+    """
+    Update assets in batch and handle any errors.
+
+    :param list[Asset] update_assets: List of assets to update
+    :rtype: None
+    """
+    try:
+        updated_assets = Asset.batch_update(update_assets, job_progress)
+        logger.info(
+            "RegScale Asset(s) successfully updated: %i/%i",
+            len(updated_assets),
+            len(update_assets),
+        )
+    except requests.RequestException as rex:
+        logger.error("Unable to Update Qualys Assets to RegScale\n%s", rex)
 
 
 def sync_issues(ssp_id: int, qualys_assets_and_issues: list[dict], is_component: bool = False) -> None:
@@ -2016,7 +2115,7 @@ def lookup_asset(asset_list: list, asset_id: str = None) -> list[Asset]:
     return list(set(asset_list)) or []
 
 
-def map_qualys_severity_to_regscale(severity: int) -> tuple[str, str]:
+def map_qualys_severity_to_regscale(severity: int) -> tuple[IssueSeverity, str]:
     """
     Map Qualys vulnerability severity to RegScale Issue severity
 
@@ -2025,12 +2124,12 @@ def map_qualys_severity_to_regscale(severity: int) -> tuple[str, str]:
     :rtype: tuple[str, str]
     """
     if severity <= 2:
-        return "III - Low - Other Weakness", "low"
+        return IssueSeverity.Low, "low"
     if severity == 3:
-        return "II - Moderate - Reportable Condition", "moderate"
+        return IssueSeverity.Moderate, "moderate"
     if severity > 3:
-        return "I - High - Significant Deficiency", "high"
-    return "IV - Not Assigned", "low"
+        return IssueSeverity.High, "high"
+    return IssueSeverity.NotAssigned, "low"
 
 
 def create_regscale_issue_from_vuln(