regscale-cli 6.20.10.0__py3-none-any.whl → 6.21.0.0__py3-none-any.whl

regscale/_version.py

@@ -33,7 +33,7 @@ def get_version_from_pyproject() -> str:
                     return match.group(1)
     except Exception:
         pass
-    return "6.20.10.0"  # fallback version
+    return "6.21.0.0"  # fallback version
 
 
 __version__ = get_version_from_pyproject()

regscale/core/app/application.py

@@ -245,6 +245,7 @@ class Application(metaclass=Singleton):
             "snowPassword": "<snowPassword>",
             "snowUrl": "<mySnowUrl>",
             "snowUserName": "<snowUserName>",
+            "sonarUrl": "https://sonarcloud.io",
             "sonarToken": "<mySonarToken>",
             "tenableAccessKey": "<tenableAccessKeyGoesHere>",
             "tenableSecretKey": "<tenableSecretKeyGoesHere>",
@@ -295,7 +296,10 @@ class Application(metaclass=Singleton):
         self.running_in_airflow = os.getenv("REGSCALE_AIRFLOW") == "true"
         if isinstance(config, str):
             config = self._read_config_from_str(config)
-        self.config = self._gen_config(config)
+        if self.running_in_airflow:
+            self.config = self._fetch_config_from_regscale(config)
+        else:
+            self.config = self._gen_config(config)
         self.os = platform.system()
         self.input_host = ""
         # Ensure maxThreads is an integer for ThreadManager
@@ -536,10 +540,6 @@ class Application(metaclass=Singleton):
             self.logger.debug("Successfully retrieved config from Click context.")
             return click_config
 
-        if self.running_in_airflow:
-            if airflow_config := self._get_airflow_config(config):
-                self.logger.debug("Successfully retrieved config from Airflow.")
-                return airflow_config
         try:
             if config and self.local_config:
                 self.logger.debug(f"Config provided as :\n{type(config)}")
@@ -572,6 +572,13 @@ class Application(metaclass=Singleton):
         return config
 
     def _get_airflow_config(self, config: Optional[Union[dict, str]] = None) -> Optional[dict]:
+        """
+        Get config from Airflow DAG config, or from the environment variables if not provided.
+
+        :param Optional[Union[dict, str]] config: Configuration dictionary, defaults to None
+        :return: Configuration dictionary
+        :rtype: Optional[dict]
+        """
         if config:
             self.logger.debug(f"Received config from Airflow as: {type(config)}")
             # check to see if config is a string because airflow can pass a string instead of a dict

regscale/core/app/internal/set_permissions.py

@@ -1,11 +1,9 @@
 import click
 from pathlib import Path
 import os
-from openpyxl import Workbook, load_workbook
-from openpyxl.styles import Protection, Font, NamedStyle
-from openpyxl.worksheet.worksheet import Worksheet
+from rich.progress import track
+from openpyxl import Workbook
 from openpyxl.worksheet.datavalidation import DataValidation
-from openpyxl import Workbook, load_workbook
 from openpyxl.utils.dataframe import dataframe_to_rows
 
 from regscale.core.app.logz import create_logger
@@ -118,38 +116,71 @@ def import_permissions_workbook(file: Path):
     """
     # Read in the spreadsheet
     records = get_records(file=file)
-    for record in records:
+    for index in track(
+        range(len(records)),
+        description="Processing rbacs...",
+    ):
+        record = records[index]
+        # Check the records:
+
         if not Group.get_object(record["group_id"]):
             logger.error(f"Group {record['group_id']} doesn't exist in this instance.  Skipping row")
             continue
 
-        regscale_module_id = Modules.get_module_to_id(record["regscale_module"])
-        regscale_id = record["regscale_id"]
-        if record[READ_UPDATE] == "R":
-            permissions = 1
-        elif record[READ_UPDATE] == "RU":
-            permissions = 2
-        else:
-            permissions = 0
-
-        # Set the record to private
         my_class = Modules.module_to_class(record["regscale_module"])
-        obj = my_class.get_object(regscale_id)
+        obj = my_class.get_object(record["regscale_id"])
         if not obj:
-            logger.error(f"RegScale {record['regscale_module']} record {regscale_id} doesn't exist. Skipping row")
+            logger.error(
+                f"RegScale {record['regscale_module']} record {record['regscale_id']} doesn't exist. Skipping row"
+            )
             continue
 
-        # Add the permission
-        RBAC.add(
-            module_id=regscale_module_id,
-            parent_id=regscale_id,
-            group_id=record["group_id"],
-            permission_type=permissions,
+        # Set the permissions
+        set_permissions(record=record)
+
+
+def set_permissions(record: dict):
+    """
+    Sets the permissions for each record
+
+    :param dict record: permissions dictionary
+    """
+
+    if record[READ_UPDATE] == "R":
+        permissions = 1
+    elif record[READ_UPDATE] == "RU":
+        permissions = 2
+    else:
+        permissions = 0
+
+    # Add the permission
+    if not RBAC.add(
+        module_id=Modules.get_module_to_id(record["regscale_module"]),
+        parent_id=record["regscale_id"],
+        group_id=record["group_id"],
+        permission_type=permissions,
+    ):
+        logger.warning(
+            f"Failed to set permissions for {record['regscale_module']} {record['regscale_id']} for group {record['group_id']}"
+        )
+        return
+
+    if not RBAC.public(
+        module_id=Modules.get_module_to_id(record["regscale_module"]),
+        parent_id=record["regscale_id"],
+        is_public=0 if record[PUBLIC_PRIVATE] == "private" else 1,
+    ):
+        logger.warning(
+            f"Failed to set public/private for {record['regscale_module']} {record['regscale_id']} for group {record['group_id']}"
         )
-        RBAC.public(
-            module_id=regscale_module_id,
-            parent_id=regscale_id,
-            is_public=0 if record[PUBLIC_PRIVATE] == "private" else 1,
+        return
+
+    if not RBAC.reset(
+        module_id=Modules.get_module_to_id(record["regscale_module"]),
+        parent_id=record["regscale_id"],
+    ):
+        logger.warning(
+            f"Failed to proliferate permissions for {record['regscale_module']} {record['regscale_id']} for group {record['group_id']}"
         )
 
 

regscale/integrations/commercial/nessus/scanner.py

@@ -83,6 +83,8 @@ class NessusIntegration(ScannerIntegration):
         for file in iterate_files(file_collection):
             content = read_file(file)
             root = ET.fromstring(content)
+            if scan_dt := nfr.scan.scan_time_start(root):
+                self.scan_date = scan_dt.strftime("%Y-%m-%d")
             for nessus_asset in nfr.scan.report_hosts(root):
                 asset_name = nfr.host.report_host_name(nessus_asset)
                 for nessus_vulnerability in root.iterfind(f"./Report/ReportHost[@name='{asset_name}']/ReportItem"):

regscale/integrations/commercial/sonarcloud.py

@@ -2,100 +2,93 @@
 # -*- coding: utf-8 -*-
 """RegScale SonarCloud Integration"""
 
-# standard python imports
+import logging
 import math
-import sys
 from typing import Optional
+from urllib.parse import urljoin
 
 import click
 import requests  # type: ignore
 
 from regscale.core.app.api import Api
 from regscale.core.app.application import Application
-from regscale.core.app.logz import create_logger
 from regscale.core.app.utils.app_utils import (
-    get_current_datetime,
     days_between,
+    error_and_exit,
+    get_current_datetime,
 )
 from regscale.models import regscale_id, regscale_module
 from regscale.models.regscale_models.assessment import Assessment
 from regscale.models.regscale_models.issue import Issue
 
-# create logger function to log to the console
-logger = create_logger()
+logger = logging.getLogger("regscale")
 
 
-def get_sonarcloud_results(config: dict) -> list[list[dict]]:
+def get_sonarcloud_results(config: dict, branch: Optional[str] = None) -> list[list[dict]]:
     """
     Retrieve Sonarcloud Results from the Sonarcloud.io API
+
     :param dict config: RegScale CLI configuration
+    :param Optional[str] branch: Branch name to filter results, defaults to None
     :return: json response data from API GET request
     :rtype: list[list[dict]]
     """
+    # create an empty list to hold multiple pages of data
+    complete = []
     # api endpoint
-    url = "https://sonarcloud.io/api/issues/search"
+    url = urljoin(config["sonarUrl"], "/api/issues/search")
     # SONAR_TOKEN from Sonarcloud
     token = config["sonarToken"]
     # arguments to pass to the API call
-    query = {
-        "organization": "regscale",
-        "projects": "RegScale_regscale",
-        "branch": "main",
-        "projectKey": "RegScale_regscale",
+    params = {
         "statuses": "OPEN, CONFIRMED, REOPENED",
-        "createdInLast": "1m",
         "ps": 500,
     }
+    if branch:
+        params["branch"] = branch
     # GET request pulls in data to check results size
-    r = requests.get(url, auth=(str(token), ""), params=query)
+    r = requests.get(url, auth=(str(token), ""), params=params)
     # if the status code does not equal 200
     if r and not r.ok:
         # exit the script gracefully
-        sys.exit("Sonarcloud API call failed please check the configuration")
+        error_and_exit(f"Sonarcloud API call failed please check the configuration\n{r.status_code}: {r.text}")
     # pull in response data to a dictionary
     data = r.json()
     # find the total results number
     total = data["paging"]["total"]
+    complete.extend(data.get("issues", []))
+    logger.info(f"Found {total} issue(s) from SonarCloud/Qube.")
     # find the number of results in each result page
     size = data["paging"]["pageSize"]
     # calculate the number of pages to iterate through sequentially
     pages = math.ceil(total / size)
-    # create an empty list to hold multiple pages of data
-    complete = []
     # loop through each page number
     for i in range(1, pages + 1, 1):
         # parameters to pass to the API call
-        filters = {
-            "organization": "regscale",
-            "projects": "RegScale_regscale",
-            "branch": "main",
-            "projectKey": "RegScale_regscale",
-            "statuses": "OPEN, CONFIRMED, REOPENED",
-            "createdInLast": "1m",
-            "ps": 500,
-            "p": f"{i}",
-        }
+        params["p"] = str(i)
         # for each page make a GET request to pull in the data
-        r = requests.get(url, auth=(str(token), ""), params=filters)
+        r = requests.get(url, auth=(str(token), ""), params=params)
         # pull in response data to a dictionary
         data = r.json()
         # extract only the issues from the data
         issues = data["issues"]
         # add each page to the total results page
-        complete.append(issues)
+        complete.extend(issues)
     # return the list of json response objects for use
+    logger.info(f"Retrieved {len(complete)}/{total} issue(s) from SonarCloud/Qube.")
     return complete
 
 
-def build_data(api: Api) -> list[dict]:
+def build_data(api: Api, branch: Optional[str] = None) -> list[dict]:
     """
     Build vulnerability alert data list
     :param Api api: API object
+    :param Optional[str] branch: Branch name to filter results, defaults to None
     :return: vulnerability data list
     :rtype: list[dict]
     """
     # execute GET request
-    data = get_sonarcloud_results(config=api.config)
+    data = get_sonarcloud_results(config=api.config, branch=branch)
     # create empty list to hold json response dicts
     vulnerability_data_list = []
     # loop through the lists in API response data
@@ -196,11 +189,14 @@ def create_alert_assessment(
         return None
 
 
-def create_alert_issues(parent_id: Optional[int] = None, parent_module: Optional[str] = None) -> None:
+def create_alert_issues(
+    parent_id: Optional[int] = None, parent_module: Optional[str] = None, branch: Optional[str] = None
+) -> None:
     """
     Create child issues from the alert assessment
     :param Optional[int] parent_id: Parent ID record to associate the assessment to, defaults to None
     :param Optional[str] parent_module: Parent module to associate the assessment to, defaults to None
+    :param Optional[str] branch: Branch name to filter results, defaults to None
     :rtype: None
     """
     # set environment and application configuration
@@ -210,7 +206,7 @@ def create_alert_issues(parent_id: Optional[int] = None, parent_module: Optional
     assessment_id = create_alert_assessment(api=api, parent_id=parent_id, parent_module=parent_module)
 
     # create vulnerability data list
-    vuln_data_list = build_data(api)
+    vuln_data_list = build_data(api, branch)
     # loop through each vulnerability alert in the list
     for vulnerability in vuln_data_list:
         # create issue model
@@ -253,8 +249,11 @@ def sonarcloud() -> None:
 @sonarcloud.command(name="sync_alerts")
 @regscale_id(required=False, default=None)
 @regscale_module(required=False, default=None)
-def create_alerts(regscale_id: Optional[int] = None, regscale_module: Optional[str] = None) -> None:
+@click.option("--branch", help="Branch name to filter results, defaults to None")
+def create_alerts(
+    regscale_id: Optional[int] = None, regscale_module: Optional[str] = None, branch: Optional[str] = None
+) -> None:
     """
     Create a child assessment and child issues in RegScale from SonarCloud alerts.
     """
-    create_alert_issues(regscale_id, regscale_module)
+    create_alert_issues(regscale_id, regscale_module, branch)

regscale/integrations/commercial/synqly/ticketing.py

@@ -100,6 +100,57 @@ def sync_jira(
     )
 
 
+@ticketing.command(name="sync_jira_service_management")
+@regscale_id()
+@regscale_module()
+@click.option(
+    "--project",
+    type=click.STRING,
+    help="jira_service_management project",
+    required=True,
+    prompt="jira_service_management project",
+)
+@click.option(
+    "--default_issue_type",
+    type=click.STRING,
+    help="Default issue type when creating tickets.",
+    required=False,
+)
+@click.option(
+    "--default_project",
+    type=click.STRING,
+    help="Default project when listing, creating, or editing tickets.",
+    required=False,
+)
+@click.option(
+    "--sync_attachments",
+    type=click.BOOL,
+    help="Whether to sync attachments between Jira Service Management and RegScale",
+    required=False,
+    default=True,
+)
+def sync_jira_service_management(
+    regscale_id: int,
+    regscale_module: str,
+    project: str,
+    default_issue_type: str,
+    default_project: str,
+    sync_attachments: bool,
+) -> None:
+    """Sync Ticketing data between Jira Service Management and RegScale."""
+    from regscale.models.integration_models.synqly_models.connectors import Ticketing
+
+    ticketing_jira_service_management = Ticketing("jira_service_management")
+    ticketing_jira_service_management.run_sync(
+        regscale_id=regscale_id,
+        regscale_module=regscale_module,
+        project=project,
+        default_issue_type=default_issue_type,
+        default_project=default_project,
+        sync_attachments=sync_attachments,
+    )
+
+
 @ticketing.command(name="sync_pagerduty")
 @regscale_id()
 @regscale_module()

regscale/integrations/integration_override.py

@@ -2,8 +2,6 @@
 A simple singleton class that loads custom integration mappings, if available
 """
 
-from regscale.core.app.application import Application
-
 # pylint: disable=C0415
 
 
@@ -74,9 +72,12 @@ class IntegrationOverride:
         :return: The mapped field name
         :rtype: Optional[str]
         """
-        if integration and self.mapping_exists(integration, field_name):
+        if integration and field_name and self.mapping_exists(integration, field_name):
             integration_map = self.mapping.get(integration.lower(), {})
-            return integration_map.get(field_name.lower())
+            # Find the actual key that matches case-insensitively
+            for key in integration_map.keys():
+                if key.lower() == field_name.lower():
+                    return integration_map.get(key)
         return None
 
     def mapping_exists(self, integration: str, field_name: str) -> bool:
@@ -88,8 +89,16 @@ class IntegrationOverride:
         :return: Whether the mapping exists
         :rtype: bool
         """
+        if not integration or not field_name:
+            return False
         the_map = self.mapping.get(integration.lower())
-        return the_map and field_name.lower() in the_map and the_map.get(field_name.lower()) != "default"
+        if not the_map:
+            return False
+        # Find the actual key that matches case-insensitively
+        for key in the_map.keys():
+            if key.lower() == field_name.lower():
+                return the_map.get(key) != "default"
+        return False
 
     def field_map_validation(self, obj: Any, model_type: str) -> Optional[str]:
         """
@@ -131,7 +140,7 @@ class IntegrationOverride:
                 },
             }
             # The type an associated fields we are able to override. Limited for now.
-            supported_fields = {"asset": {"ipAddress", "name", "fqdn", "dns"}}
+            supported_fields = {"asset": {"ipAddress", "name", "fqdn", "dns"}, "issue": {"dateFirstDetected"}}
             if regscale_field not in supported_fields.get(model_type.lower(), set()):
                 return match