regscale-cli 6.16.0.0__py3-none-any.whl

regscale/integrations/variables.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Scanner Variables"""
+
+from regscale.core.app.utils.variables import RsVariablesMeta, RsVariableType
+
+
+class ScannerVariables(metaclass=RsVariablesMeta):
+    """
+    Scanner Variables class to define class-level attributes with type annotations and examples
+    """
+
+    # Define class-level attributes with type annotations and examples
+    issueCreation: RsVariableType(str, "PerAsset|Consolidated", default="Consolidated", required=False)  # type: ignore # noqa: F722,F821
+    vulnerabilityCreation: RsVariableType(str, "NoIssue|IssueCreation|PoamCreation", default="PoamCreation", required=False)  # type: ignore  # noqa: F722,F821
+    userId: RsVariableType(str, "00000000-0000-0000-0000-000000000000")  # type: ignore # noqa: F722,F821
+    poamTitleType: RsVariableType(str, "Cve|PluginId", default="Cve", required=False)  # type: ignore # noqa: F722,F821
+    tenableGroupByPlugin: RsVariableType(bool, "true|false", default=False, required=False)  # type: ignore # noqa: F722,F821
+    threadMaxWorkers: RsVariableType(int, "1-8", default=4, required=False)  # type: ignore # noqa: F722,F821
+    stigMapperFile: RsVariableType(str, "stig_mapper.json", default="stig_mapper_rules.json", required=False)  # type: ignore # noqa: F722,F821
+    ingestClosedIssues: RsVariableType(bool, "true|false", default=False, required=False)  # type: ignore # noqa: F722,F821
+    # Increment the POAM identifier by 1 for each new POAM created in the format of V-0001
+    incrementPoamIdentifier: RsVariableType(bool, "true|false", default=False, required=False)  # type: ignore # noqa: F722,F821
+    sslVerify: RsVariableType(bool, "true|false", default=True, required=False)  # type: ignore # noqa: F722,F821
+    issueDueDates: RsVariableType(dict, "dueDates", default="{'high': 60, 'moderate': 120, 'low': 364}", required=False)  # type: ignore # noqa: F722,F821

regscale/models/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""standard python imports"""
+from regscale.models.app_models.click import regscale_id, regscale_module, regscale_ssp_id
+from .regscale_models import *
+from .integration_models import *
+from .app_models import *

regscale/models/app_models/__init__.py

@@ -0,0 +1,5 @@
+"""App models for RegScale CLI"""
+
+from .mapping import Mapping
+from .import_validater import ImportValidater
+from .datetime_encoder import DateTimeEncoder

regscale/models/app_models/catalog_compare.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Dataclass for a RegScale Assessment"""
+import re
+import sys
+from dataclasses import asdict, dataclass
+from typing import Any, Optional
+
+from regscale.core.app.api import Api
+from regscale.core.app.logz import create_logger
+
+
+@dataclass
+class CatalogCompare:
+    """Catalog comparison Model"""
+
+    title: Optional[str] = None
+    uuid: Optional[str] = None
+    keywords: Optional[list] = None
+    cci_count: int = 0
+    objective_count: int = 0
+    parameter_count: int = 0
+    security_control_count: int = 0
+    test_count: int = 0
+
+    def __getitem__(self, key: Any) -> Any:
+        """
+        Get attribute from CatalogCompare
+
+        :param Any key: Key to get value from
+        :return: value of provided key
+        :rtype: Any
+        """
+        return getattr(self, key)
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        """
+        Set attribute in CatalogCompare with provided key
+
+        :param Any key: Key to change to provided value
+        :param Any value: New value for provided Key
+        :rtype: None
+        """
+        return setattr(self, key, value)
+
+    def dict(self) -> dict:
+        """
+        Create a dictionary from the CatalogCompare dataclass
+
+        :return: Dictionary of CatalogCompare
+        :rtype: dict
+        """
+        return {k: v for k, v in asdict(self).items()}
+
+    @staticmethod
+    def from_new_catalog_dict(obj: dict, keywords: list = None) -> "CatalogCompare":
+        """
+        Create CatalogCompare object from dict
+
+        :param dict obj: dictionary of a newly formatted catalog
+        :param list keywords: list of keywords for the catalog
+        :return: CatalogCompare class
+        :rtype: CatalogCompare
+        """
+        _title = str(obj["catalog"].get("title", "")) or None
+        _uuid = str(obj["catalog"].get("uuid", "")) or None
+        _keywords = keywords
+        _cci_count = 0
+        _objective_count = 0
+        _parameter_count = 0
+        _test_count = 0
+        _security_control_count = 0
+        for control in obj["catalog"].get("securityControls", []):
+            _objective_count += len(control.get("objectives", []))
+            _cci_count += len(control.get("cci", []))
+            _parameter_count += len(control.get("parameters", []))
+            _test_count += len(control.get("tests", []))
+            _security_control_count += 1
+
+        return CatalogCompare(
+            title=_title,
+            uuid=_uuid,
+            keywords=_keywords,
+            cci_count=_cci_count,
+            objective_count=_objective_count,
+            parameter_count=_parameter_count,
+            security_control_count=_security_control_count,
+            test_count=_test_count,
+        )
+
+    @staticmethod
+    def from_old_catalog_dict(obj: dict, keywords: list = None) -> "CatalogCompare":
+        """
+        Create CatalogCompare object from dict
+
+        :param dict obj: dictionary of an old formatted catalog
+        :param list keywords: list of keywords for the catalog
+        :return: CatalogCompare class
+        :rtype: CatalogCompare
+        """
+        _title = str(obj.get("title", "")) or None
+        _uuid = str(obj.get("uuid", "")) or None
+        _keywords = keywords
+        _cci_count = int(obj.get("cci", 0)) or 0
+        _objective_count = int(obj.get("objectives", 0)) or 0
+        _parameter_count = int(obj.get("parameters", 0)) or 0
+        _security_control_count = int(obj.get("securityControls", 0)) or 0
+        _test_count = int(obj.get("tests", 0)) or 0
+
+        return CatalogCompare(
+            title=_title,
+            uuid=_uuid,
+            keywords=_keywords,
+            cci_count=_cci_count,
+            objective_count=_objective_count,
+            parameter_count=_parameter_count,
+            security_control_count=_security_control_count,
+            test_count=_test_count,
+        )
+
+    @staticmethod
+    def run_new_diagnostics(
+        new_diagnose_cat: dict,
+    ) -> "CatalogCompare":
+        """
+        Run diagnostics on new catalog
+
+        :param dict new_diagnose_cat: dictionary of the new catalog
+        :return: CatalogCompare class
+        :rtype: CatalogCompare
+        """
+        new_list = []
+        # get keywords list from catalog
+        # https://stackoverflow.com/questions/4998629/split-string-with-multiple-delimiters-in-python
+        keywords_list = re.split(r"; |, |\*|\n", new_diagnose_cat.get("keywords", ""))
+        for keyword in keywords_list:
+            new_key = keyword.replace("<p>", "").replace("</p>", "").lstrip()
+            new_list.append(new_key)
+
+        return CatalogCompare().from_new_catalog_dict(new_diagnose_cat, new_list)
+
+    @staticmethod
+    def run_old_diagnostics(
+        old_diagnose_cat: dict,
+    ) -> "CatalogCompare":
+        """
+        Function to run diagnostics on the old catalog
+
+        :param dict old_diagnose_cat: dictionary of the old catalog
+        :return: CatalogCompare object
+        :rtype: CatalogCompare
+        """
+        # set variables for catalog section
+        cci_count = 0
+        objective_count = 0
+        parameter_count = 0
+        test_count = 0
+        new_list = []
+        # get keywords list from catalog
+        # https://stackoverflow.com/questions/4998629/split-string-with-multiple-delimiters-in-python
+        keywords_list = re.split(r"; |, |\*|\n", old_diagnose_cat.get("keywords", ""))
+        for keyword in keywords_list:
+            new_key = keyword.replace("<p>", "").replace("</p>", "").lstrip()
+            new_list.append(new_key)
+        # loop through security controls
+        for control in old_diagnose_cat["securityControls"]:
+            # count objectives in security controls
+            for objectives in control["objectives"]:
+                if objectives.get("uuid"):
+                    objective_count += 1
+            # count parametes in security controls
+            for parameters in control["parameters"]:
+                if parameters.get("uuid"):
+                    parameter_count += 1
+            # count ccis in security controls
+            for ccis in control["cci"]:
+                if ccis.get("uuid"):
+                    cci_count += 1
+            # count tests in security controls
+            for tests in control["tests"]:
+                if tests.get("uuid"):
+                    test_count += 1
+        return CatalogCompare(
+            title=old_diagnose_cat.get("title", ""),
+            uuid=old_diagnose_cat.get("uuid", ""),
+            keywords=new_list,
+            cci_count=cci_count,
+            objective_count=objective_count,
+            parameter_count=parameter_count,
+            security_control_count=len(old_diagnose_cat.get("securityControls", 0)),
+            test_count=test_count,
+        )
+
+    @staticmethod
+    def get_master_catalogs(api: Api) -> dict:
+        """
+        Get list of master catalogs via API
+
+        :param Api api: API object
+        :return: master catalog list
+        :rtype: dict
+        """
+        catalog_url = "https://regscaleblob.blob.core.windows.net/catalogs/catalog_registry.json"
+        response = api.get(url=catalog_url, headers={})
+        try:
+            master_list = response.json()
+        except Exception:
+            logger = create_logger()
+            logger.error("Unable to retrieve master catalogs.")
+            sys.exit(1)
+        # Filter out catalogs without downloadURL
+        master_list["catalogs"] = [cat for cat in master_list.get("catalogs") if cat.get("downloadURL")]
+        return master_list

regscale/models/app_models/click.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Module to allow dynamic click arguments and store commonly used click commands"""
+
+from typing import Tuple, Any, Optional
+
+import click
+from pathlib import Path
+
+
+class NotRequiredIf(click.Option):
+    """
+    NotRequiredIf class for dynamic click options Updates the help command to let the user know if a
+    command is exclusive or not
+
+    :param Tuple *args: List of arguments
+    :param **kwargs: Dictionary of keyword arguments
+    """
+
+    def __init__(self, *args: Tuple, **kwargs):
+        self.not_required_if: list = kwargs.pop("not_required_if")
+
+        assert self.not_required_if, "'not_required_if' parameter required"
+        kwargs["help"] = (
+            kwargs.get("help", "") + "Option is mutually exclusive with " + ", ".join(self.not_required_if) + "."
+        ).strip()
+        super(NotRequiredIf, self).__init__(*args, **kwargs)
+
+    def handle_parse_result(self, ctx: Any, opts: Any, args: Any) -> Any:
+        """
+        Function to handle the click arguments and whether a parameter is required
+
+        :param Any ctx: Any context
+        :param Any opts: Any options
+        :param Any args: Any arguments
+        :raises click.UsageError: Raises a UsageError if the option is mutually exclusive
+        :return: Returns the click option
+        :rtype: Any
+        """
+        current_opt: bool = self.name in opts
+        for mutex_opt in self.not_required_if:
+            if mutex_opt in opts:
+                if current_opt:
+                    raise click.UsageError(
+                        "Illegal usage: '" + str(self.name) + "' is mutually exclusive with " + str(mutex_opt) + "."
+                    )
+                else:
+                    self.prompt = None
+        return super(NotRequiredIf, self).handle_parse_result(ctx, opts, args)
+
+
+def save_output_to(exists: bool = False, dir_okay: bool = True, file_okay: bool = False) -> click.option:
+    """
+    Function to return a click.option for saving data to a directory
+
+    :param bool exists: Whether the directory has to exist, default False
+    :param bool dir_okay:  Whether to accept a directory, default True
+    :param bool file_okay:  Whether a file path will be accepted, default False
+    :return: click.option with the provided parameters
+    :rtype: click.option
+    """
+    return click.option(
+        "--save_output_to",
+        type=click.Path(
+            exists=exists,
+            dir_okay=dir_okay,
+            file_okay=file_okay,
+            path_type=Path,
+        ),
+        help="Provide the path where you would like to save the output to.",
+        prompt="Enter directory for file output",
+        required=True,
+    )
+
+
+def file_types(accepted_files: list) -> click.option:
+    """
+    Function to return click.option for accepted file types
+
+    :param list accepted_files: list of file extensions
+    :return: click.option with provided file list
+    :rtype: click.option
+    """
+    return click.option(
+        "--file_type",
+        type=click.Choice(accepted_files, case_sensitive=False),
+        help="Select a file type to save the output as.",
+        prompt="Enter desired file type",
+        required=True,
+    )
+
+
+def regscale_ssp_id(
+    help: str = "The ID number from RegScale of the System Security Plan",
+    required: bool = True,
+    **kwargs: dict,
+) -> click.option:
+    """
+    Function to return click.option for RegScale SSP ID
+
+    :param str help: String to display when user enters --help
+    :param bool required: Whether input is required, defaults to True
+    :param dict **kwargs: kwargs to pass to click.option
+    :return: click.option for RegScale SSP ID
+    :rtype: click.option
+    """
+    if "prompt" not in kwargs:
+        return click.option(
+            "--regscale_ssp_id",
+            "-id",
+            "--id",
+            "--regscale_id",
+            type=click.INT,
+            help=help,
+            required=required,
+            prompt="Enter the RegScale System Security Plan ID",
+            **kwargs,
+        )
+    return click.option(
+        "--regscale_id",
+        "-id",
+        "--id",
+        "--regscale_id",
+        type=click.INT,
+        help=help,
+        required=required,
+        **kwargs,
+    )
+
+
+def regscale_id(
+    help: str = "Enter the desired ID # from RegScale.",
+    required: bool = True,
+    **kwargs,
+) -> click.option:
+    """
+    Function to return click.option for RegScale parent ID
+
+    :param str help: String to display when user enters --help
+    :param bool required: Whether input is required, defaults to True
+    :param **kwargs: kwargs to pass to click.option
+    :return: click.option for RegScale parent ID
+    :rtype: click.option
+    """
+    if kwargs.get("prompt") is None:
+        return click.option(
+            "--regscale_id",
+            "-id",
+            "--id",
+            type=click.INT,
+            help=help,
+            prompt="Enter the RegScale Record ID",
+            required=required,
+            **kwargs,
+        )
+    return click.option(
+        "--regscale_id",
+        "-id",
+        "--id",
+        type=click.INT,
+        help=help,
+        required=required,
+        **kwargs,
+    )
+
+
+def regscale_module(required: bool = True, **kwargs) -> click.option:
+    """
+    Function to return click.option for RegScale modules
+
+    :param bool required: Whether input is required, defaults to True
+    :param **kwargs: kwargs to pass to click.option
+    :return: click.option for RegScale modules
+    :rtype: click.option
+    """
+    from regscale.models.regscale_models.modules import Modules
+
+    if kwargs.get("prompt") is None:
+        return click.option(
+            "--regscale_module",
+            "-m",
+            type=click.STRING,
+            help=f"Enter the RegScale module name.\n\n{Modules().to_str_table()}",
+            prompt="Enter the RegScale Module name",
+            required=required,
+            **kwargs,
+        )
+    return click.option(
+        "--regscale_module",
+        "-m",
+        type=click.STRING,
+        help=f"Enter the RegScale module name.\n\n{Modules().to_str_table()}",
+        required=required,
+        **kwargs,
+    )
+
+
+def hidden_file_path(**kwargs) -> click.option:
+    """
+    Function to return a hidden click.option for file path
+    """
+    return click.option(
+        "--offline",
+        type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path, resolve_path=True),
+        help=kwargs.pop("help") if kwargs.get("help") else "Enter the file path",
+        hidden=True,
+        default=kwargs.get("default"),
+        **kwargs,
+    )
+
+
+def show_mapping(group: click.Group, import_name: str, file_type: Optional[str] = None) -> click.Command:
+    """
+    Show the mapping for the given import_name
+
+    :param click.Group group: The click group to register the command with
+    :param str import_name: The name of the import function
+    :param Optional[str] file_type: The file type of the import, defaults to None
+    :return: The decorated function.
+    :rtype: Callable[[Callable], click.option]
+    """
+    import os
+
+    # Define default path based on import_name and file_type
+    default = os.path.join("./", "mappings", import_name, f"{file_type}_mapping.json") if file_type else None
+
+    @click.command(help=f"Show the mapping file used during {import_name} imports.")
+    @click.option(
+        "--file_path",
+        "-f",
+        help="File path to the mapping file to display",
+        type=click.Path(exists=True, dir_okay=False, file_okay=True, resolve_path=True),
+        required=True,
+        default=default if default else None,
+    )
+    # Define the desired function behavior
+    def wrapped_func(file_path: str) -> None:
+        """
+        Show the mapping file used during imports
+        """
+        import json
+        from rich.console import Console
+
+        console = Console()
+        with open(file_path, "r", encoding="utf-8") as file:
+            mapping = json.load(file)
+        dat = json.dumps(mapping, indent=4)
+        console.print(f"{file_path} mapping:")
+        console.print(dat)
+
+    # Register the decorated function with the given click group
+    group.add_command(wrapped_func, name="show_mapping")

regscale/models/app_models/datetime_encoder.py

@@ -0,0 +1,21 @@
+"""
+This module provides a custom JSON encoder for handling datetime objects.
+"""
+
+import datetime
+import json
+from typing import Any
+
+
+class DateTimeEncoder(json.JSONEncoder):
+    """
+    Custom JSON encoder that converts datetime objects to ISO format strings.
+    """
+
+    def default(self, obj: Any) -> Any:
+        """
+        Override the default method to handle datetime objects.
+        """
+        if isinstance(obj, datetime.datetime):
+            return obj.isoformat()
+        return super().default(obj)