regscale-cli 6.20.7.0__py3-none-any.whl → 6.20.8.0__py3-none-any.whl

regscale/integrations/commercial/qualys/__init__.py

@@ -35,7 +35,7 @@ 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
+from regscale.models.app_models.click import NotRequiredIf, regscale_ssp_id, 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,
@@ -303,7 +303,7 @@ class FindingProgressTracker:
 
 
 @click.command(name="import_total_cloud")
-@regscale_ssp_id()
+@ssp_or_component_id()
 @click.option(
     "--include_tags",
     "-t",
@@ -341,21 +341,37 @@ class FindingProgressTracker:
     default=True,
 )
 def import_total_cloud(
-    regscale_ssp_id: int,
-    include_tags: str,
-    exclude_tags: str,
-    vulnerability_creation: str,
-    ssl_verify: bool,
-    containers: bool,
+    regscale_ssp_id: int = None,
+    component_id: int = None,
+    include_tags: str = None,
+    exclude_tags: str = None,
+    vulnerability_creation: str = None,
+    ssl_verify: bool = None,
+    containers: bool = True,
 ):
     """
     Import Qualys Total Cloud Assets and Vulnerabilities using JSONL scanner implementation.
 
     This command uses the JSONLScannerIntegration class for improved efficiency and memory management.
     """
-    if not validate_regscale_object(regscale_ssp_id, "securityplans"):
-        logger.warning("SSP #%i is not a valid RegScale Security Plan.", regscale_ssp_id)
-        return
+    # Determine which ID to use and whether it's a component
+    if component_id:
+        plan_id = component_id
+        is_component = True
+        if not validate_regscale_object(component_id, "components"):
+            logger.warning("Component #%i is not a valid RegScale Component.", component_id)
+            return
+    elif regscale_ssp_id:
+        plan_id = regscale_ssp_id
+        is_component = False
+        if not validate_regscale_object(regscale_ssp_id, "securityplans"):
+            logger.warning("SSP #%i is not a valid RegScale Security Plan.", regscale_ssp_id)
+            return
+    else:
+        raise click.UsageError(
+            "You must provide either a --regscale_ssp_id or a --component_id to import Qualys Total Cloud data."
+        )
+
     containers_lst = []
     try:
         # Configure scanner variables and fetch data
@@ -370,7 +386,7 @@ def import_total_cloud(
 
         # Initialize and run integration
         integration = _initialize_integration(
-            regscale_ssp_id, response_data, vulnerability_creation, ssl_verify, containers_lst
+            plan_id, response_data, vulnerability_creation, ssl_verify, containers_lst, is_component
         )
         _run_integration_import(integration)
 
@@ -483,31 +499,18 @@ def _fetch_qualys_api_data(include_tags, exclude_tags):
         return None
 
 
-def _initialize_integration(regscale_ssp_id, response_data, vulnerability_creation, ssl_verify, containers):
-    """Initialize the scanner integration with appropriate settings.
-
-    :param int regscale_ssp_id: RegScale SSP ID
-    :param dict response_data: Parsed XML data from API
-    :param str vulnerability_creation: Vulnerability creation mode
-    :param bool ssl_verify: SSL verification setting
-    :param list containers: List of containers
-    :return: Initialized integration object
-    """
-    # Build integration kwargs
+def _initialize_integration(plan_id, response_data, vulnerability_creation, ssl_verify, containers, is_component=False):
     integration_kwargs = {
-        "plan_id": regscale_ssp_id,
+        "plan_id": plan_id,
         "xml_data": response_data,
         "vulnerability_creation": vulnerability_creation or ScannerVariables.vulnerabilityCreation,
         "ssl_verify": ssl_verify if ssl_verify is not None else ScannerVariables.sslVerify,
         "containers": containers,
+        "is_component": is_component,
     }
-
-    # Add thread workers if available
     if hasattr(ScannerVariables, "threadMaxWorkers"):
         integration_kwargs["max_workers"] = ScannerVariables.threadMaxWorkers
         logger.debug(f"Using thread max workers: {ScannerVariables.threadMaxWorkers}")
-
-    # Initialize and return integration
     integration = QualysTotalCloudJSONLIntegration(**integration_kwargs)
     return integration
 
@@ -539,7 +542,7 @@ def _run_integration_import(integration):
 
 
 @click.command(name="import_total_cloud_xml")
-@regscale_ssp_id()
+@ssp_or_component_id()
 @click.option(
     "--xml_file",
     "-f",
@@ -547,7 +550,7 @@ def _run_integration_import(integration):
     required=True,
     help="Path to Qualys Total Cloud XML file to process.",
 )
-def import_total_cloud_from_xml(regscale_ssp_id: int, xml_file: str):
+def import_total_cloud_from_xml(xml_file: str, regscale_ssp_id: int = None, component_id: int = None):
     """
     Import Qualys Total Cloud Assets and Vulnerabilities from an existing XML file using JSONL scanner.
 
@@ -582,9 +585,27 @@ def import_total_cloud_from_xml(regscale_ssp_id: int, xml_file: str):
             QualysErrorHandler.log_error_details(error_details)
             return
 
+        # Determine which ID to use and whether it's a component
+        if component_id:
+            plan_id = component_id
+            is_component = True
+            if not validate_regscale_object(component_id, "components"):
+                logger.warning("Component #%i is not a valid RegScale Component.", component_id)
+                return
+        elif regscale_ssp_id:
+            plan_id = regscale_ssp_id
+            is_component = False
+            if not validate_regscale_object(regscale_ssp_id, "securityplans"):
+                logger.warning("SSP #%i is not a valid RegScale Security Plan.", regscale_ssp_id)
+                return
+        else:
+            raise click.UsageError(
+                "You must provide either a --regscale_ssp_id or a --component_id to import Qualys Total Cloud data."
+            )
+
         # Initialize the JSONLScannerIntegration implementation
         integration = QualysTotalCloudJSONLIntegration(
-            plan_id=regscale_ssp_id, xml_data=response_data, file_path=xml_file
+            plan_id=plan_id, xml_data=response_data, file_path=xml_file, is_component=is_component
         )
 
         # Process data and generate JSONL files
@@ -878,7 +899,7 @@ def import_qualys_scans(
         import_name="Qualys",
         file_types=[".csv", ".xlsx"],
         folder_path=folder_path,
-        regscale_ssp_id=regscale_ssp_id,
+        object_id=regscale_ssp_id,
         scan_date=scan_date,
         mappings_path=mappings_path,
         disable_mapping=disable_mapping,
@@ -951,13 +972,22 @@ def save_results(save_output_to: Path, scan_id: str):
     save_scan_results_by_id(save_path=save_output_to, scan_id=scan_id)
 
 
+def _resolve_plan_and_component(regscale_ssp_id: int = None, component_id: int = None):
+    """
+    Utility to resolve plan_id and is_component from regscale_ssp_id and component_id.
+    Returns (plan_id, is_component)
+    """
+    if (regscale_ssp_id is None and component_id is None) or (regscale_ssp_id and component_id):
+        raise click.UsageError("You must provide either --regscale_ssp_id or --component_id, but not both.")
+    is_component = component_id is not None
+    plan_id = component_id if is_component else regscale_ssp_id
+    return plan_id, is_component
+
+
 @qualys.command(name="sync_qualys")
-@click.option(
-    "--regscale_ssp_id",
-    type=click.INT,
-    required=True,
-    prompt="Enter RegScale System Security Plan ID",
-    help="The ID number from RegScale of the System Security Plan",
+@ssp_or_component_id(
+    ssp_kwargs={"help": "The ID number from RegScale of the System Security Plan."},
+    component_kwargs={"help": "The ID number from RegScale of the Component record to sync to."},
 )
 @click.option(
     "--create_issue",
@@ -983,20 +1013,22 @@ def save_results(save_output_to: Path, scan_id: str):
     not_required_if=["asset_group_id"],
 )
 def sync_qualys(
-    regscale_ssp_id: int,
+    regscale_ssp_id: int = None,
+    component_id: int = None,
     create_issue: bool = False,
     asset_group_id: int = None,
     asset_group_name: str = None,
 ):
     """
-    Query Qualys and sync assets & their associated
-    vulnerabilities to a Security Plan in RegScale.
+    Query Qualys and sync assets & their associated vulnerabilities to a Security Plan or Component in RegScale.
     """
+    plan_id, is_component = _resolve_plan_and_component(regscale_ssp_id, component_id)
     sync_qualys_to_regscale(
-        regscale_ssp_id=regscale_ssp_id,
+        plan_id=plan_id,
         create_issue=create_issue,
         asset_group_id=asset_group_id,
         asset_group_name=asset_group_name,
+        is_component=is_component,
     )
 
 
@@ -1259,18 +1291,20 @@ def save_scan_results_by_id(save_path: Path, scan_id: str) -> None:
 
 
 def sync_qualys_to_regscale(
-    regscale_ssp_id: int,
+    plan_id: int,
     create_issue: bool = False,
     asset_group_id: int = None,
     asset_group_name: str = None,
+    is_component: bool = False,
 ) -> None:
     """
-    Sync Qualys assets and vulnerabilities to a security plan in RegScale
+    Sync Qualys assets and vulnerabilities to a security plan or component in RegScale
 
-    :param int regscale_ssp_id: ID # of the SSP in RegScale
+    :param int plan_id: ID # of the SSP or Component in RegScale
     :param bool create_issue: Flag whether to create an issue in RegScale from Qualys vulnerabilities, defaults to False
     :param int asset_group_id: Optional filter for assets in Qualys with an asset group ID, defaults to None
     :param str asset_group_name: Optional filter for assets in Qualys with an asset group name, defaults to None
+    :param bool is_component: Whether the sync is for a component (True) or security plan (False)
     :rtype: None
     """
     # see if user has enterprise license
@@ -1278,21 +1312,21 @@ def sync_qualys_to_regscale(
 
     # check if the user provided an asset group id or name
     if asset_group_id:
-        # get the assets from Qualys using the group name
         sync_qualys_assets_and_vulns(
-            ssp_id=regscale_ssp_id,
+            ssp_id=plan_id,
             create_issue=create_issue,
             asset_group_filter=asset_group_name,
+            is_component=is_component,
         )
     elif asset_group_name:
-        # get the assets from Qualys using the group name
         sync_qualys_assets_and_vulns(
-            ssp_id=regscale_ssp_id,
+            ssp_id=plan_id,
             create_issue=create_issue,
             asset_group_filter=asset_group_id,
+            is_component=is_component,
         )
     else:
-        sync_qualys_assets_and_vulns(ssp_id=regscale_ssp_id, create_issue=create_issue)
+        sync_qualys_assets_and_vulns(ssp_id=plan_id, create_issue=create_issue, is_component=is_component)
 
 
 def get_scan_results(scans: Any, task: TaskID) -> dict:
@@ -1594,28 +1628,32 @@ def sync_qualys_assets_and_vulns(
     ssp_id: int,
     create_issue: bool,
     asset_group_filter: Optional[Union[int, str]] = None,
+    is_component: bool = False,
 ) -> None:
     """
-    Function to query Qualys and sync assets & associated vulnerabilities to RegScale
+    Function to query Qualys and sync assets & associated vulnerabilities to RegScale (Security Plan or Component)
 
-    :param int ssp_id: RegScale System Security Plan ID
+    :param int ssp_id: RegScale System Security Plan or Component ID
     :param bool create_issue: Flag to create an issue in RegScale for each vulnerability from Qualys
     :param Optional[Union[int, str]] asset_group_filter: Filter the Qualys assets by an asset group ID or name, if any
+    :param bool is_component: Whether the sync is for a component (True) or security plan (False)
     :rtype: None
     """
     config = _get_config()
+    parent_module = "components" if is_component else "securityplans"
 
-    # Get the assets from RegScale with the provided SSP ID
-    logger.info("Getting assets from RegScale for SSP #%s...", ssp_id)
-    reg_assets = Asset.get_all_by_search(search=Search(parentID=ssp_id, module="securityplans"))
+    # Get the assets from RegScale with the provided parent ID
+    logger.info(f"Getting assets from RegScale for {parent_module} #{ssp_id}...")
+    reg_assets = Asset.get_all_by_search(search=Search(parentID=ssp_id, module=parent_module))
     logger.info(
-        "Located %s asset(s) associated with SSP #%s in RegScale.",
+        "Located %s asset(s) associated with %s #%s in RegScale.",
         len(reg_assets),
+        parent_module,
         ssp_id,
     )
     logger.debug(reg_assets)
 
-    if qualys_assets := get_qualys_assets_and_scan_results(asset_group_filter):
+    if qualys_assets := get_qualys_assets_and_scan_results(asset_group_filter=asset_group_filter):
         logger.info("Received %s assets from Qualys.", len(qualys_assets))
         logger.debug(qualys_assets)
     else:
@@ -1625,6 +1663,7 @@ def sync_qualys_assets_and_vulns(
         reg_assets=reg_assets,
         ssp_id=ssp_id,
         config=config,
+        is_component=is_component,
     )
     if create_issue:
         # Get vulnerabilities from Qualys for the Qualys assets
@@ -1635,26 +1674,35 @@ def sync_qualys_assets_and_vulns(
         sync_issues(
             ssp_id=ssp_id,
             qualys_assets_and_issues=qualys_assets_and_issues,
+            is_component=is_component,
         )
 
 
-def sync_assets(qualys_assets: list[dict], reg_assets: list[Asset], ssp_id: int, config: dict) -> None:
+def sync_assets(
+    qualys_assets: list[dict], reg_assets: list[Asset], ssp_id: int, config: dict, is_component: bool = False
+) -> None:
     """
-    Function to sync Qualys assets to RegScale
+    Function to sync Qualys assets to RegScale (Security Plan or Component)
 
     :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 ID
+    :param int ssp_id: RegScale System Security Plan or Component ID
     :param dict config: Configuration dictionary
+    :param bool is_component: Whether the sync is for a component (True) or security plan (False)
     :rtype: None
     """
+    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
-        # Update parent id to SSP on insert
+        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 = "securityplans"
+                asset.parentModule = parent_module
                 asset.otherTrackingNumber = qualys_asset["ID"]
                 asset.ipAddress = qualys_asset["IP"]
                 asset.qualysId = qualys_asset["ASSET_ID"]
@@ -1666,23 +1714,35 @@ def sync_assets(qualys_assets: list[dict], reg_assets: list[Asset], ssp_id: int,
                 except AssertionError as aex:
                     logger.error("Asset does not have an id, unable to update!\n%s", aex)
     update_and_insert_assets(
-        qualys_assets=qualys_assets, reg_assets=reg_assets, ssp_id=ssp_id, config=config, update_assets=update_assets
+        qualys_assets=qualys_assets,
+        reg_assets=reg_assets,
+        ssp_id=ssp_id,
+        config=config,
+        update_assets=update_assets,
+        is_component=is_component,
     )
 
 
 def update_and_insert_assets(
-    qualys_assets: list[dict], reg_assets: list[Asset], ssp_id: int, config: dict, update_assets: list[Asset]
+    qualys_assets: list[dict],
+    reg_assets: list[Asset],
+    ssp_id: int,
+    config: dict,
+    update_assets: list[Asset],
+    is_component: bool = False,
 ) -> None:
     """
-    Function to update and insert Qualys assets into RegScale
+    Function to update and insert Qualys assets into RegScale (Security Plan or Component)
 
     :param list[dict] qualys_assets: List of Qualys assets as dictionaries
     :param list[Asset] reg_assets: List of RegScale assets
-    :param int ssp_id: RegScale System Security Plan ID
+    :param int ssp_id: RegScale System Security Plan or Component ID
     :param dict config: RegScale CLI Configuration dictionary
     :param list[Asset] update_assets: List of assets to update in RegScale
+    :param bool is_component: Whether the sync is for a component (True) or security plan (False)
     :rtype: None
     """
+    parent_module = "components" if is_component else "securityplans"
     insert_assets = []
     if assets_to_be_inserted := [
         qualys_asset
@@ -1695,7 +1755,7 @@ def update_and_insert_assets(
                 name=f'Qualys Asset #{qualys_asset["ASSET_ID"]} IP: {qualys_asset["IP"]}',
                 otherTrackingNumber=qualys_asset["ID"],
                 parentId=ssp_id,
-                parentModule="securityplans",
+                parentModule=parent_module,
                 ipAddress=qualys_asset["IP"],
                 assetOwnerId=config["userId"],
                 assetType="Other",
@@ -1727,22 +1787,28 @@ def update_and_insert_assets(
             logger.error("Unable to Update Qualys Assets to RegScale\n%s", rex)
 
 
-def sync_issues(ssp_id: int, qualys_assets_and_issues: list[dict]) -> None:
+def sync_issues(ssp_id: int, qualys_assets_and_issues: list[dict], is_component: bool = False) -> None:
     """
-    Function to sync Qualys issues to RegScale
+    Function to sync Qualys issues to RegScale (Security Plan or Component)
 
-    :param int ssp_id: RegScale System Security Plan ID
+    :param int ssp_id: RegScale System Security Plan or Component ID
     :param list[dict] qualys_assets_and_issues: List of Qualys assets and their issues
+    :param bool is_component: Whether the sync is for a component (True) or security plan (False)
     :rtype: None
     """
+    parent_module = "components" if is_component else "securityplans"
     update_issues = []
     insert_issues = []
     vuln_count = 0
-    ssp_assets = Asset.get_all_by_parent(parent_id=ssp_id, parent_module="securityplans")
+    ssp_assets = Asset.get_all_by_parent(parent_id=ssp_id, parent_module=parent_module)
     for asset in qualys_assets_and_issues:
         # Create issues in RegScale from Qualys vulnerabilities
         regscale_issue_updates, regscale_new_issues = create_regscale_issue_from_vuln(
-            regscale_ssp_id=ssp_id, qualys_asset=asset, regscale_assets=ssp_assets, vulns=asset["ISSUES"]
+            regscale_ssp_id=ssp_id,
+            qualys_asset=asset,
+            regscale_assets=ssp_assets,
+            vulns=asset["ISSUES"],
+            is_component=is_component,
         )
         update_issues.extend(regscale_issue_updates)
         insert_issues.extend(regscale_new_issues)
@@ -1840,6 +1906,11 @@ def get_qualys_assets_and_scan_results(
         # parse the xml data from response.text and convert it to a dictionary
         # and try to extract the data from the parsed XML dictionary
         asset_data = res_data["HOST_LIST_VM_DETECTION_OUTPUT"]["RESPONSE"]["HOST_LIST"]["HOST"]
+        # Always make asset_data a list
+        if isinstance(asset_data, dict):
+            asset_data = [asset_data]
+        elif not isinstance(asset_data, list):
+            asset_data = []
         # check if we need to paginate the asset data
         if "WARNING" in res_data["HOST_LIST_VM_DETECTION_OUTPUT"]["RESPONSE"]:
             logger.warning("Not all assets were fetched, fetching more assets from Qualys...")
@@ -2025,22 +2096,24 @@ def map_qualys_severity_to_regscale(severity: int) -> tuple[str, str]:
 
 
 def create_regscale_issue_from_vuln(
-    regscale_ssp_id: int, qualys_asset: dict, regscale_assets: list[Asset], vulns: dict
+    regscale_ssp_id: int, qualys_asset: dict, regscale_assets: list[Asset], vulns: dict, is_component: bool = False
 ) -> Tuple[list[Issue], list[Issue]]:
     """
-    Sync Qualys vulnerabilities to RegScale issues.
+    Sync Qualys vulnerabilities to RegScale issues (Security Plan or Component).
 
-    :param int regscale_ssp_id: RegScale SSP ID
+    :param int regscale_ssp_id: RegScale SSP or Component ID
     :param dict qualys_asset: Qualys asset as a dictionary
     :param list[Asset] regscale_assets: list of RegScale assets
     :param dict vulns: dictionary of Qualys vulnerabilities associated with the provided asset
+    :param bool is_component: Whether the sync is for a component (True) or security plan (False)
     :return: list of RegScale issues to update, and a list of issues to be created
     :rtype: Tuple[list[Issue], list[Issue]]
     """
     config = _get_config()
     default_status = config["issues"]["qualys"]["status"]
     regscale_issues = []
-    regscale_existing_issues = Issue.get_all_by_parent(parent_id=regscale_ssp_id, parent_module="securityplans")
+    parent_module = "components" if is_component else "securityplans"
+    regscale_existing_issues = Issue.get_all_by_parent(parent_id=regscale_ssp_id, parent_module=parent_module)
     for vuln in vulns.values():
         asset_identifier = None
         severity, key = map_qualys_severity_to_regscale(int(vuln["SEVERITY"]))
@@ -2071,7 +2144,7 @@ def create_regscale_issue_from_vuln(
             dueDate=due_date.strftime(fmt),
             identification="Vulnerability Assessment",
             parentId=regscale_ssp_id,
-            parentModule="securityplans",
+            parentModule=parent_module,
             recommendedActions=vuln["ISSUE_DATA"]["SOLUTION"],
             assetIdentifier=asset_identifier,
         )

regscale/integrations/commercial/qualys/containers.py

@@ -150,6 +150,7 @@ def _fetch_paginated_data(endpoint: str, filters: Optional[Dict] = None, limit:
     """
     all_items = []
     page: int = 1
+    current_url = None  # Ensure current_url is always defined
 
     try:
         # Get authentication
@@ -214,7 +215,7 @@ def _fetch_paginated_data(endpoint: str, filters: Optional[Dict] = None, limit:
                 params = {}
 
     except Exception as e:
-        logger.error("Error fetching data from %s: %s", current_url, e)
+        logger.error("Error fetching data from %s: %s", current_url if current_url else "N/A", e)
         logger.debug(traceback.format_exc())
 
     logger.info("Completed: Fetched %s total items from %s", len(all_items), endpoint)

regscale/integrations/commercial/qualys/scanner.py

@@ -67,10 +67,12 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
 
         :param Any *args: Variable positional arguments
         :param Any **kwargs: Variable keyword arguments
+        :param bool is_component: Whether to upload to a component record (default: False)
         """
         self.type = ScannerIntegrationType.VULNERABILITY
         self.xml_data = kwargs.pop("xml_data", None)
         self.containers = kwargs.pop("containers", None)
+        self.is_component = kwargs.get("is_component", False)
         # Setting a dummy file path to avoid validation errors
         if self.xml_data and "file_path" not in kwargs:
             kwargs["file_path"] = None
@@ -210,7 +212,7 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
             asset_category="IT",
             status=AssetStatus.Active,
             parent_id=self.plan_id,
-            parent_module="securityplans",
+            parent_module="components" if self.is_component else "securityplans",
             notes="Generated for missing Qualys data",
         )
 
@@ -244,7 +246,7 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
             vlan_id=host_info["network_id"],
             notes=f"Qualys Asset ID: {host_info['host_id']}",
             parent_id=self.plan_id,
-            parent_module="securityplans",
+            parent_module="components" if self.is_component else "securityplans",
         )
 
     def _extract_host_from_structure(self, host_data):
@@ -1044,7 +1046,7 @@ class QualysTotalCloudJSONLIntegration(JSONLScannerIntegration):
                 mac_address=None,
                 notes=f"Qualys Container ID: {container_id}. Image ID: {image_id}. SHA: {sha}",
                 parent_id=self.plan_id,
-                parent_module="securityplans",
+                parent_module="components" if self.is_component else "securityplans",
                 is_virtual=True,
             )
 

regscale/integrations/commercial/snyk.py

@@ -21,10 +21,12 @@ def snyk():
     message="File path to the folder containing Snyk .xlsx or .json files to process to RegScale.",
     prompt="File path for Snyk files",
     import_name="snyk",
+    support_component=True,
 )
 def import_snyk(
     folder_path: PathLike[str],
     regscale_ssp_id: int,
+    component_id: int,
     scan_date: datetime,
     mappings_path: PathLike[str],
     disable_mapping: bool,
@@ -36,9 +38,14 @@ def import_snyk(
     """
     Import scans, vulnerabilities and assets to RegScale from Snyk export files
     """
+
+    if not regscale_ssp_id and not component_id:
+        raise click.UsageError("You must provide either a --regscale_ssp_id or a --component_id to import Snyk scans.")
+
     import_synk_files(
         folder_path=folder_path,
-        regscale_ssp_id=regscale_ssp_id,
+        object_id=component_id if component_id else regscale_ssp_id,
+        is_component=bool(component_id),
         scan_date=scan_date,
         mappings_path=mappings_path,
         disable_mapping=disable_mapping,
@@ -51,7 +58,8 @@ def import_snyk(
 
 def import_synk_files(
     folder_path: PathLike[str],
-    regscale_ssp_id: int,
+    object_id: int,
+    is_component: bool,
     scan_date: datetime,
     mappings_path: PathLike[str],
     disable_mapping: bool,
@@ -64,7 +72,7 @@ def import_synk_files(
     Import Snyk scans, vulnerabilities and assets to RegScale from Snyk files
 
     :param PathLike[str] folder_path: File path to the folder containing Snyk .xlsx files to process to RegScale
-    :param int regscale_ssp_id: The RegScale SSP ID
+    :param int object_id: The RegScale SSP ID or Component ID
     :param datetime scan_date: The date of the scan
     :param PathLike[str] mappings_path: The path to the mappings file
     :param bool disable_mapping: Whether to disable custom mappings
@@ -72,6 +80,7 @@ def import_synk_files(
     :param str s3_prefix: The S3 prefix to download the files from
     :param str aws_profile: The AWS profile to use for S3 access
     :param Optional[bool] upload_file: Whether to upload the file to RegScale after processing, defaults to True
+    :param bool is_component: Whether the object is a component
     :rtype: None
     """
     FlatFileImporter.import_files(
@@ -79,7 +88,7 @@ def import_synk_files(
         import_name="Snyk",
         file_types=[".xlsx", ".json"],
         folder_path=folder_path,
-        regscale_ssp_id=regscale_ssp_id,
+        object_id=object_id,
         scan_date=scan_date,
         mappings_path=mappings_path,
         disable_mapping=disable_mapping,
@@ -87,4 +96,5 @@ def import_synk_files(
         s3_prefix=s3_prefix,
         aws_profile=aws_profile,
         upload_file=upload_file,
+        is_component=is_component,
     )