regscale-cli 6.20.4.0__py3-none-any.whl → 6.20.5.0__py3-none-any.whl

regscale/integrations/commercial/qualys/scanner.py

@@ -7,23 +7,26 @@ import os
 import time
 import traceback
 import xml.etree.ElementTree as ET
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union, TextIO
-
+from datetime import date, datetime
+from io import TextIOWrapper
 from pathlib import Path
-from rich.progress import Progress, TextColumn, BarColumn, SpinnerColumn, TimeElapsedColumn, TaskID
+from typing import Any, Dict, Iterator, List, Optional, TextIO, Tuple, Union
+
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskID, TextColumn, TimeElapsedColumn
 
 from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.core.utils.date import date_obj, date_str, normalize_timestamp
+from regscale.integrations.commercial.qualys.qualys_error_handler import QualysErrorHandler
 from regscale.integrations.commercial.qualys.variables import QualysVariables
 from regscale.integrations.jsonl_scanner_integration import JSONLScannerIntegration
 from regscale.integrations.scanner_integration import (
     IntegrationAsset,
     IntegrationFinding,
-    issue_due_date,
     ScannerIntegrationType,
+    issue_due_date,
 )
 from regscale.integrations.variables import ScannerVariables
 from regscale.models import AssetStatus, IssueSeverity, IssueStatus
-from regscale.integrations.commercial.qualys.qualys_error_handler import QualysErrorHandler
 
 logger = logging.getLogger("regscale")
 
@@ -55,6 +58,8 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
     # Constants for file paths
     ASSETS_FILE = "./artifacts/qualys_total_cloud_assets.jsonl"
     FINDINGS_FILE = "./artifacts/qualys_total_cloud_findings.jsonl"
+    CONTAINERS_FILE = "./artifacts/qualys_total_cloud_containers.jsonl"
+    CONTAINER_FINDINGS_FILE = "./artifacts/qualys_total_cloud_container_findings.jsonl"
 
     def __init__(self, *args, **kwargs):
         """
@@ -65,6 +70,7 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
         """
         self.type = ScannerIntegrationType.VULNERABILITY
         self.xml_data = kwargs.pop("xml_data", None)
+        self.containers = kwargs.pop("containers", None)
         # Setting a dummy file path to avoid validation errors
         if self.xml_data and "file_path" not in kwargs:
             kwargs["file_path"] = None
@@ -875,7 +881,9 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
         logger.info(f"Found {num_findings} total findings in XML dictionary data")
 
         # Process assets and findings
-        self._process_dict_assets_and_findings(hosts_data, all_findings)
+        self._process_dict_assets_and_findings(
+            hosts_data=hosts_data, all_findings=all_findings, containers_data=self.containers
+        )
 
     def _extract_hosts_from_dict(self):
         """Extract host data from XML dictionary structure."""
@@ -914,11 +922,19 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
 
         return all_findings
 
-    def _process_dict_assets_and_findings(self, hosts_data, all_findings):
-        """Process assets and findings from dictionary data."""
+    def _process_dict_assets_and_findings(self, hosts_data, all_findings, containers_data=None):
+        """
+        Process assets and findings from dictionary data.
+        :param List[Dict[str, Any]] hosts_data: List of host data dictionaries
+        :param List[Dict[str, Any]] all_findings: List of findings dictionaries
+        :param List[Dict[str, Any]] containers_data: List of container data dictionaries
+        """
         with open(self.ASSETS_FILE, "w") as assets_file, open(self.FINDINGS_FILE, "w") as findings_file:
             self._write_assets_from_dict(assets_file, hosts_data)
             self._write_findings_from_dict(findings_file, all_findings)
+            if containers_data:
+                self._write_containers_from_dict(assets_file, containers_data)
+                self._write_container_findings_from_dict(findings_file, containers_data)
 
     def _write_assets_from_dict(self, assets_file, hosts_data):
         """Write assets from dictionary data to JSONL file."""
@@ -949,6 +965,160 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
 
         logger.info(f"Wrote {findings_written} findings to {self.FINDINGS_FILE}")
 
+    def _write_containers_from_dict(
+        self, containers_file: TextIOWrapper, containers_data: List[Dict[str, Any]]
+    ) -> None:
+        """
+        Write containers from dictionary data to JSONL file.
+
+        :param TextIOWrapper containers_file: Open file handle to write containers to
+        :param List[Dict[str, Any]] containers_data: List of container dictionaries to process
+        """
+        containers_written = 0
+        for container in containers_data:
+            try:
+                if container_asset := self.parse_container_asset(container=container):
+                    self._write_item(containers_file, container_asset)
+                    containers_written += 1
+            except Exception as e:
+                logger.error(f"Error processing container: {str(e)}")
+                logger.debug(traceback.format_exc())
+
+        logger.info("Wrote %s containers to %s", containers_written, containers_file.name)
+
+    def _write_container_findings_from_dict(
+        self, container_findings_file: TextIOWrapper, container_findings_data: List[Dict[str, Any]]
+    ):
+        """
+        Write container findings from dictionary data to JSONL file.
+
+        :param TextIOWrapper container_findings_file: Path to the container findings file
+        :param List[Dict[str, Any]] container_findings_data: Dictionary of container findings data
+        """
+        findings_written = 0
+        for finding in container_findings_data:
+            try:
+                container_id = finding.get("containerId", "")
+                if parsed_finding := self.parse_container_finding(finding=finding, container_id=container_id):
+                    self._write_item(container_findings_file, parsed_finding)
+                    findings_written += 1
+            except Exception as e:
+                logger.error(f"Error processing container finding: {str(e)}")
+                logger.debug(traceback.format_exc())
+
+        logger.info("Wrote %s container findings to %s", findings_written, container_findings_file.name)
+
+    def parse_container_asset(self, container: dict) -> Optional[IntegrationAsset]:
+        """
+        Parse a single container asset from Qualys container data.
+
+        :param container: Dictionary representing a container
+        :return: IntegrationAsset object
+        :rtype: Optional[IntegrationAsset]
+        """
+        state_map = {
+            "running": AssetStatus.Active,
+            "stopped": AssetStatus.Inactive,
+            "paused": AssetStatus.Inactive,
+            "restarting": AssetStatus.Active,
+            "exited": AssetStatus.Inactive,
+        }
+        try:
+            # Extract container information
+            container_id = container.get("containerId", "")
+            name = container.get("name", "Unknown Container")
+            image_id = container.get("imageId", "")
+            state = container.get("state", "stopped")
+            sha = container.get("sha", "")
+            state_changed = self._convert_timestamp_to_date_str(container.get("stateChanged", ""))
+
+            return IntegrationAsset(
+                name=name,
+                identifier=container_id,
+                asset_type="Virtual Machine (VM)",
+                asset_category="Hardware",
+                operating_system="Linux",
+                status=state_map.get((state or "running").lower(), AssetStatus.Inactive),
+                external_id=container_id,
+                date_last_updated=state_changed,
+                mac_address=None,
+                notes=f"Qualys Container ID: {container_id}. Image ID: {image_id}. SHA: {sha}",
+                parent_id=self.plan_id,
+                parent_module="securityplans",
+                is_virtual=True,
+            )
+
+        except Exception as e:
+            logger.error(f"Error parsing container asset: {str(e)}")
+            logger.debug(traceback.format_exc())
+
+    def parse_container_finding(self, finding: dict, container_id: str):
+        """
+        Parse a single container finding from Qualys container vulnerability data.
+
+        :param dict finding: Dictionary representing a container vulnerability
+        :param str container_id: Container ID associated with the finding
+        :return: IntegrationFinding object
+        :rtype: Optional[IntegrationFinding]
+        """
+
+        vulns: List[dict] = finding.get("vulnerabilities")
+        severity_map = {
+            "1": IssueSeverity.Critical,
+            "2": IssueSeverity.High,
+            "3": IssueSeverity.Moderate,
+            "4": IssueSeverity.Low,
+            "5": IssueSeverity.NotAssigned,
+        }
+
+        for vuln in vulns:
+            try:
+                # Extract finding information
+                title = vuln.get("title", "Unknown Container Vulnerability")
+                severity_num = vuln.get("severity", 0)
+                severity = severity_map.get(str(severity_num), IssueSeverity.NotAssigned)
+                description = vuln.get("result", "No description available")
+                status = vuln.get("status", "New")
+                vuln_id = vuln.get("id", "")
+
+                qid = vuln.get("qid", "")
+
+                # Get current time for any missing date fields
+                current_time = self.scan_date or get_current_datetime()
+
+                # Convert timestamp to datetime if needed
+                first_found = vuln.get("firstFound", current_time)
+                last_found = vuln.get("lastFound", current_time)
+
+                # Handle timestamp conversion if it's a numeric timestamp
+                first_found = self._convert_timestamp_to_date_str(first_found)
+                last_found = self._convert_timestamp_to_date_str(last_found)
+
+                cve = next(iter(vuln.get("cveids", [])), "")
+                # Create finding object
+                return IntegrationFinding(
+                    title=title,
+                    description=description,
+                    severity=severity,
+                    status=self.get_finding_status(status),
+                    external_id=vuln_id,
+                    asset_identifier=container_id,
+                    cve=cve,
+                    category="Vulnerability",
+                    plugin_name=cve or f"QID-{qid}",
+                    control_labels=[f"QID-{qid}"],
+                    cvss_v3_base_score=vuln.get("cvss3Info", {}).get("baseScore"),
+                    cvss_v3_vector=vuln.get("cvss3Info", {}).get("temporalScore"),
+                    first_seen=first_found,
+                    last_seen=last_found,
+                    evidence=vuln.get("result", "No evidence available"),
+                )
+
+            except Exception as e:
+                logger.error(f"Error parsing container finding: {str(e)}")
+                logger.debug(traceback.format_exc())
+                continue  # Continue to next vulnerability if this one fails
+
     def _process_xml_elements(self, hosts):
         """Process XML element hosts and detections with progress tracking."""
         # Convert XML elements to dictionaries first
@@ -1154,6 +1324,31 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
 
         return unique_id
 
+    def _convert_timestamp_to_date_str(self, timestamp_value: Any) -> str:
+        """
+        Convert a timestamp value to a date string with validation.
+
+        :param Any timestamp_value: The timestamp value to convert
+        :return: Date string in ISO format
+        :raises ValueError: If the timestamp is not numeric
+        :rtype: str
+        """
+        try:
+            # Handle empty or None values early
+            if not timestamp_value and timestamp_value != 0:
+                raise ValueError(f"Invalid timestamp value: {timestamp_value}, defaulting to current datetime")
+
+            # Convert to integer timestamp
+            timestamp_int = normalize_timestamp(timestamp_value)
+
+            s = date_obj(timestamp_int)
+            if not s or timestamp_int == 0:
+                raise ValueError(f"Invalid timestamp value: {timestamp_value}, defaulting to current datetime")
+            return date_str(s)
+        except ValueError as e:
+            logger.error(f"Error converting timestamp to date string: {str(e)}")
+            return get_current_datetime()
+
     def get_finding_status(self, status: Optional[str]) -> IssueStatus:
         """
         Convert the Qualys status to a RegScale issue status.

regscale/integrations/commercial/synqly/edr.py

@@ -87,4 +87,14 @@ def sync_sophos(regscale_ssp_id: int, url: str) -> None:
     edr_sophos.run_sync(regscale_ssp_id=regscale_ssp_id, url=url)
 
 
+@edr.command(name="sync_tanium")
+@regscale_ssp_id()
+def sync_tanium(regscale_ssp_id: int) -> None:
+    """Sync Edr from Tanium to RegScale."""
+    from regscale.models.integration_models.synqly_models.connectors import Edr
+
+    edr_tanium = Edr("tanium")
+    edr_tanium.run_sync(regscale_ssp_id=regscale_ssp_id)
+
+
 # pylint: enable=line-too-long

regscale/integrations/commercial/wizv2/click.py

@@ -360,9 +360,9 @@ def add_report_evidence(
     "--catalog_id",
     "-c",
     help="RegScale Catalog ID for the selected framework.",
-    prompt="RegScale Catalog ID",
     hide_input=False,
-    required=True,
+    required=False,
+    default=None,
 )
 @click.option(  # type: ignore
     "--framework",

regscale/integrations/commercial/wizv2/constants.py

@@ -304,6 +304,19 @@ DOWNLOAD_QUERY = """
         }
     }
     """
+RERUN_REPORT_QUERY = """
+    mutation RerunReport($reportId: ID!) {
+        rerunReport(input: {id: $reportId}) {
+            report {
+                id
+                lastRun {
+                    url
+                    status
+                }
+            }
+        }
+    }
+    """
 ISSUE_QUERY = """query IssuesTable(
   $filterBy: IssueFilters
   $first: Int

regscale/integrations/commercial/wizv2/issue.py

@@ -5,8 +5,9 @@ import re
 from typing import List, Dict, Any, Iterator, Optional
 
 from regscale.core.app.utils.parser_utils import safe_datetime_str
-from regscale.integrations.scanner_integration import issue_due_date, IntegrationFinding
+from regscale.integrations.scanner_integration import IntegrationFinding
 from regscale.utils.dict_utils import get_value
+from regscale.models import Issue
 from .constants import (
     get_wiz_issue_queries,
     WizVulnerabilityType,
@@ -353,7 +354,7 @@ class WizIssue(WizVulnerabilityIntegration):
             source_rule_id=source_rule_id,
             vulnerability_type=vulnerability_type.value,
             date_created=date_created,
-            due_date=issue_due_date(severity, date_created),
+            due_date=Issue.get_due_date(severity, self.app.config, "wiz", date_created),
             recommendation_for_mitigation=source_rule.get("resolutionRecommendation")
             or wiz_issue.get("description", ""),
             poam_comments=None,

regscale/integrations/commercial/wizv2/scanner.py

@@ -167,7 +167,9 @@ class WizVulnerabilityIntegration(ScannerIntegration):
             if not asset_id:
                 return None
 
+            first_seen = node.get("firstDetectedAt") or node.get("firstSeenAt") or get_current_datetime()
             severity = self.get_issue_severity(node.get("severity", "Low"))
+            due_date = regscale_models.Issue.get_due_date(severity, self.app.config, "wiz", first_seen)
 
             status = self.map_status_to_issue_status(node.get("status", "Open"))
             name: str = node.get("name", "")
@@ -186,7 +188,8 @@ class WizVulnerabilityIntegration(ScannerIntegration):
                 status=status,
                 asset_identifier=asset_id,
                 external_id=f"{node.get('sourceRule', {'id': cve}).get('id')}",
-                first_seen=node.get("firstDetectedAt") or node.get("firstSeenAt") or get_current_datetime(),
+                first_seen=first_seen,
+                date_created=first_seen,
                 last_seen=node.get("lastDetectedAt") or node.get("analyzedAt") or get_current_datetime(),
                 remediation=node.get("description", ""),
                 cvss_score=node.get("score"),
@@ -195,6 +198,7 @@ class WizVulnerabilityIntegration(ScannerIntegration):
                 cvss_v3_base_score=node.get("score"),
                 source_rule_id=node.get("sourceRule", {}).get("id"),
                 vulnerability_type=vulnerability_type.value,
+                due_date=due_date,
             )
         except (KeyError, TypeError, ValueError) as e:
             logger.error("Error parsing Wiz finding: %s", str(e), exc_info=True)

regscale/integrations/commercial/wizv2/utils.py

@@ -16,6 +16,7 @@ from zipfile import ZipFile
 import cachetools
 import requests
 from pydantic import ValidationError
+from rich.progress import Progress, TaskID
 
 from regscale.core.app.api import Api
 from regscale.core.app.utils.app_utils import (
@@ -27,19 +28,29 @@ from regscale.core.app.utils.app_utils import (
 )
 from regscale.core.utils.date import datetime_obj
 from regscale.integrations.commercial.wizv2.constants import (
-    DOWNLOAD_QUERY,
     BEARER,
-    REPORTS_QUERY,
+    CHECK_INTERVAL_FOR_DOWNLOAD_REPORT,
     CONTENT_TYPE,
-    RATE_LIMIT_MSG,
     CREATE_REPORT_QUERY,
+    DOWNLOAD_QUERY,
     MAX_RETRIES,
-    CHECK_INTERVAL_FOR_DOWNLOAD_REPORT,
+    RATE_LIMIT_MSG,
+    REPORTS_QUERY,
+    RERUN_REPORT_QUERY,
 )
 from regscale.integrations.commercial.wizv2.models import ComplianceReport, ComplianceCheckStatus
 from regscale.integrations.commercial.wizv2.variables import WizVariables
 from regscale.integrations.commercial.wizv2.wiz_auth import wiz_authenticate
-from regscale.models import File, Sbom, SecurityPlan, Catalog, ControlImplementation, Assessment, regscale_models
+from regscale.models import (
+    File,
+    Sbom,
+    SecurityControl,
+    SecurityPlan,
+    Catalog,
+    ControlImplementation,
+    Assessment,
+    regscale_models,
+)
 from regscale.utils import PaginatedGraphQLClient
 from regscale.utils.decorators import deprecated
 
@@ -439,13 +450,14 @@ def fetch_report_data(report_id: str) -> List[Dict]:
     """
     try:
         download_url = get_report_url_and_status(report_id)
-        logger.info(f"Fetching report {report_id} from: {download_url}")
+        logger.debug(f"Fetching report {report_id} from: {download_url}")
 
         with closing(requests.get(url=download_url, stream=True, timeout=10)) as response:
             response.raise_for_status()
-            logger.info(f"Streaming and parsing report {report_id}")
+            logger.info(f"Streaming and parsing report {report_id}...")
 
             reader = csv.DictReader(codecs.iterdecode(response.iter_lines(), encoding="utf-8"), delimiter=",")
+            logger.info(f"Report {report_id} fetched successfully.")
             return list(reader)
     except requests.RequestException as e:
         error_and_exit(f"Failed to fetch report {report_id}: {str(e)}")
@@ -586,7 +598,7 @@ def send_request(
     """
     logger.debug("Sending a request to Wiz API")
     api = Api()
-    payload = dict({"query": query, "variables": variables})
+    payload = {"query": query, "variables": variables}
     if api_endpoint_url is None:
         api_endpoint_url = WizVariables.wizUrl
     if WizVariables.wizAccessToken:
@@ -650,8 +662,7 @@ def get_report_url_and_status(report_id: str) -> str:
             raise requests.RequestException("Failed to download report")
 
         response_json = response.json()
-        errors = response_json.get("errors")
-        if errors:
+        if errors := response_json.get("errors"):
             message = errors[0]["message"]
             if RATE_LIMIT_MSG in message:
                 rate = errors[0]["extensions"]["retryAfter"]
@@ -664,6 +675,10 @@ def get_report_url_and_status(report_id: str) -> str:
             status = response_json.get("data", {}).get("report", {}).get("lastRun", {}).get("status")
             if status == "COMPLETED":
                 return response_json["data"]["report"]["lastRun"]["url"]
+            elif status == "EXPIRED":
+                logger.warning("Report %s is expired, rerunning report...", report_id)
+                rerun_expired_report({"reportId": report_id})
+                return get_report_url_and_status(report_id)
 
     raise requests.RequestException("Download failed, exceeding the maximum number of retries")
 
@@ -680,13 +695,25 @@ def download_report(variables: Dict) -> requests.Response:
     return response
 
 
+def rerun_expired_report(variables: Dict) -> requests.Response:
+    """
+    Rerun a report
+
+    :param Dict variables: Variables for Wiz request
+    :return: Response object from Wiz API
+    :rtype: requests.Response
+    """
+    response = send_request(RERUN_REPORT_QUERY, variables=variables)
+    return response
+
+
 def _sync_compliance(
     wiz_project_id: str,
     regscale_id: int,
     regscale_module: str,
     client_id: str,
     client_secret: str,
-    catalog_id: int,
+    catalog_id: Optional[int] = None,
     framework: Optional[str] = "NIST800-53R5",
 ) -> List[ComplianceReport]:
     """
@@ -697,7 +724,7 @@ def _sync_compliance(
     :param str regscale_module: RegScale module
     :param str client_id: Wiz Client ID
     :param str client_secret: Wiz Client Secret
-    :param int catalog_id: Catalog ID, defaults to None
+    :param Optional[int] catalog_id: Catalog ID, defaults to None
     :param Optional[str] framework: Framework, defaults to NIST800-53R5
     :return: List of ComplianceReport objects
     :rtype: List[ComplianceReport]
@@ -708,68 +735,84 @@ def _sync_compliance(
         client_id=client_id,
         client_secret=client_secret,
     )
-    report_job = compliance_job_progress.add_task("[#f68d1f]Fetching Wiz compliance report...", total=1)
-    fetch_regscale_data_job = compliance_job_progress.add_task(
-        "[#f68d1f]Fetching RegScale Catalog info for framework...", total=1
-    )
-    logger.info("Fetching Wiz compliance report for project ID %s...", wiz_project_id)
-    compliance_job_progress.update(report_job, completed=True, advance=1)
+    with compliance_job_progress:
+        report_job = compliance_job_progress.add_task("[#f68d1f]Fetching Wiz compliance report...", total=1)
+        fetch_regscale_data_job = compliance_job_progress.add_task(
+            "[#f68d1f]Fetching RegScale Catalog info for framework...", total=1
+        )
+        compliance_job_progress.update(report_job, completed=True, advance=1)
 
-    framework_mapping = {
-        "CSF": "NIST CSF v1.1",
-        "NIST800-53R5": "NIST SP 800-53 Revision 5",
-        "NIST800-53R4": "NIST SP 800-53 Revision 4",
-    }
-    sync_framework = framework_mapping.get(framework)
-    snake_framework = sync_framework.replace(" ", "_")
-    logger.debug(f"{snake_framework=}")
-    logger.info("Fetching Wiz compliance report for project ID %s", wiz_project_id)
-    report_data = fetch_framework_report(wiz_project_id, snake_framework)
-    report_models = []
-    compliance_job_progress.update(report_job, completed=True, advance=1)
-
-    catalog = Catalog.get_with_all_details(catalog_id=catalog_id)
-    controls = catalog.get("controls") if catalog else []
-    passing_controls = {}
-    failing_controls = {}
-    controls_to_reports = {}
-
-    compliance_job_progress.update(fetch_regscale_data_job, completed=True, advance=1)
-    logger.info("Analyzing ComplianceReport for framework %s from Wiz" % sync_framework)
-    running_compliance_job = compliance_job_progress.add_task(
-        "[#f68d1f]Building compliance posture from wiz report...",
-        total=len(report_data),
-    )
-    for row in report_data:
-        try:
-            cr = ComplianceReport(**row)
-            if cr.framework == sync_framework:
-                check_compliance(
-                    cr,
-                    controls,
-                    passing_controls,
-                    failing_controls,
-                    controls_to_reports,
-                )
-                report_models.append(cr)
+        framework_mapping = {
+            "CSF": "NIST CSF v1.1",
+            "NIST800-53R5": "NIST SP 800-53 Revision 5",
+            "NIST800-53R4": "NIST SP 800-53 Revision 4",
+        }
+        sync_framework = framework_mapping.get(framework)
+        snake_framework = sync_framework.replace(" ", "_")
+        logger.debug(f"{snake_framework=}")
+        logger.info("Fetching Wiz compliance report for project ID %s...", wiz_project_id)
+        report_data = fetch_framework_report(wiz_project_id, snake_framework)
+        report_models = []
+        compliance_job_progress.update(report_job, completed=True, advance=1)
+
+        if catalog_id:
+            logger.info("Fetching all Controls for catalog #%d...", catalog_id)
+            catalog = Catalog.get_with_all_details(catalog_id=catalog_id)
+            controls = catalog.get("controls") if catalog else []
+        else:
+            # get all of the ControlImplementations for the security plan and get the controls from them
+            logger.info("Fetching all Controls for %s #%d...", regscale_module, regscale_id)
+            controls = SecurityControl.get_controls_by_parent_id_and_module(
+                parent_module=regscale_module, parent_id=regscale_id, return_dicts=True
+            )
+        logger.info("Received %d control(s) from RegScale.", len(controls))
+
+        passing_controls = {}
+        failing_controls = {}
+        controls_to_reports = {}
+
+        compliance_job_progress.update(fetch_regscale_data_job, completed=True, advance=1)
+        logger.info("Analyzing ComplianceReport for framework %s from Wiz...", sync_framework)
+        running_compliance_job = compliance_job_progress.add_task(
+            "[#f68d1f]Building compliance posture from wiz report...",
+            total=len(report_data),
+        )
+        for row in report_data:
+            try:
+                cr = ComplianceReport(**row)
+                if cr.framework == sync_framework:
+                    check_compliance(
+                        cr,
+                        controls,
+                        passing_controls,
+                        failing_controls,
+                        controls_to_reports,
+                    )
+                    report_models.append(cr)
+            except ValidationError:
+                error_message = traceback.format_exc()
+                logger.error(f"Error creating ComplianceReport: {error_message}")
+            finally:
                 compliance_job_progress.update(running_compliance_job, advance=1)
-        except ValidationError:
+        try:
+            saving_regscale_data_job = compliance_job_progress.add_task(
+                "[#f68d1f]Saving RegScale data...", total=len(controls_to_reports)
+            )
+            create_assessment_from_compliance_report(
+                controls_to_reports=controls_to_reports,
+                regscale_id=regscale_id,
+                regscale_module=regscale_module,
+                controls=controls,
+                progress=compliance_job_progress,
+                task=saving_regscale_data_job,
+            )
+            logger.info("Completed saving RegScale data.")
+        except Exception:
             error_message = traceback.format_exc()
-            logger.error(f"Error creating ComplianceReport: {error_message}")
-    try:
-        saving_regscale_data_job = compliance_job_progress.add_task("[#f68d1f]Saving RegScale data...", total=1)
-        create_assessment_from_compliance_report(
-            controls_to_reports=controls_to_reports,
-            regscale_id=regscale_id,
-            regscale_module=regscale_module,
-            controls=controls,
-        )
-        compliance_job_progress.update(saving_regscale_data_job, completed=True, advance=1)
-
-    except Exception:
-        error_message = traceback.format_exc()
-        logger.error(f"Error creating ControlImplementations from compliance report: {error_message}")
-    return report_models
+            logger.error(f"Error creating ControlImplementations from compliance report: {error_message}")
+        finally:
+            compliance_job_progress.update(saving_regscale_data_job, completed=True, advance=len(controls_to_reports))
+        return report_models
 
 
 def check_compliance(
@@ -833,7 +876,7 @@ def _clean_passing_list(passing: Dict, failing: Dict) -> None:
 
 
 def create_assessment_from_compliance_report(
-    controls_to_reports: Dict, regscale_id: int, regscale_module: str, controls: List
+    controls_to_reports: Dict, regscale_id: int, regscale_module: str, controls: List, progress: Progress, task: TaskID
 ) -> None:
     """
     Create assessment from compliance report
@@ -842,6 +885,8 @@ def create_assessment_from_compliance_report(
     :param int regscale_id: RegScale ID
     :param str regscale_module: RegScale module
     :param List controls: Controls
+    :param Progress progress: Progress object, used for progress bar updates
+    :param TaskID task: Task ID, used for progress bar updates
     :return: None
     :rtype: None
     """
@@ -854,6 +899,7 @@ def create_assessment_from_compliance_report(
                 break
         filtered_results = [x for x in implementations if x.controlID == control_record_id]
         create_report_assessment(filtered_results, reports, control_id)
+        progress.update(task, advance=1)
 
 
 def create_report_assessment(filtered_results: List, reports: List, control_id: str) -> None: