regscale-cli 6.16.0.0__py3-none-any.whl

regscale/core/app/utils/catalog_utils/common.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Enables comparison of catalogs from the master catalog list and the user's RegScale instance"""
+import json
+import logging
+import re
+from urllib.parse import urlparse
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+def get_new_catalog(url: str) -> dict:
+    """
+    Function to download a catalog via API call
+
+    :param str url: URL to download the catalog from
+    :return: Catalog API response as a dictionary
+    :rtype: dict
+    """
+    # make sure url is stripped
+    url = url.strip()
+    new_catalog = {}
+    try:
+        # call curl command to download the catalog
+        response = requests.get(url, timeout=60)
+        # parse into a dictionary
+        new_catalog = response.json()
+    except (requests.exceptions.MissingSchema, json.JSONDecodeError, requests.exceptions.RequestException) as ex:
+        logger.error("Error: %s on Catalog URL: %s", ex, url)
+    # return from the function
+    return new_catalog
+
+
+def is_valid_url(url: str) -> bool:
+    """
+    Function to validate URL
+
+    :param str url: URL to validate
+    :return: Whether the URL is valid
+    :rtype: bool
+    """
+    try:
+        result = urlparse(url)
+        return all([result.scheme, result.netloc])
+    except ValueError:
+        return False
+
+
+def dot_to_parentheses(input_string: str) -> str:
+    """
+    Converts dot-separated issue identifiers to parentheses format.
+
+    :param str input_string: The string containing issue identifiers in dot-separated format.
+    :return: A string with issue identifiers converted to parentheses format.
+    :rtype: str
+    """
+    return re.sub(r"([A-Z]+-\d+)\.(\d+)", r"\1(\2)", input_string.upper())
+
+
+def parentheses_to_dot(input_string: str) -> str:
+    """
+    Converts parentheses-separated issue identifiers back to dot format.
+
+    :param str input_string: The string containing issue identifiers in parentheses format.
+    :return: A string with issue identifiers converted back to dot format.
+    :rtype: str
+    """
+    return re.sub(r"([A-Z]+-\d+)\((\d+)\)", r"\1.\2", input_string.upper()).lower()
+
+
+def objective_to_control_dot(input_string: str) -> str:
+    """
+    Converts objective identifiers to control identifiers in dot format.
+
+    :param str input_string: The string containing objective identifiers.
+    :return: A string with objective identifiers converted to control identifiers in dot format.
+    :rtype: str
+    """
+    # Convert the input string to lowercase
+    input_string = input_string.lower()
+
+    # Use regex to find the pattern and extract the desired part
+    match = re.match(r"([a-z]+-\d+(\.\d+)?)", input_string)
+
+    if match:
+        return match.group(1)
+    else:
+        logger.error(f"Failed to convert objective to control: {input_string}")
+        return input_string

regscale/core/app/utils/catalog_utils/compare_catalog.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Enables comparison of catalogs from the master catalog list and the user's RegScale instance"""
+import logging
+
+# Standard Imports
+import operator
+
+import click  # type: ignore
+import requests  # type: ignore
+
+from regscale.core.app.api import Api
+from regscale.core.app.logz import create_logger
+from regscale.core.app.utils.app_utils import create_progress_object, error_and_exit
+from regscale.core.app.utils.catalog_utils.common import get_new_catalog
+from regscale.models.app_models.catalog_compare import CatalogCompare
+
+# pylint: disable=line-too-long
+
+
+def display_menu() -> None:
+    """
+    Start the process of comparing two catalogs, one from the master catalog list
+    and one from the user's RegScale instance
+
+    :rtype: None
+    """
+    # set environment and application configuration
+    api = Api()
+    api.timeout = 180
+
+    # create logger function to log to the console
+    job_progress = create_progress_object()
+    logger = create_logger()
+    menu_counter: list = []
+    download_url: str = ""
+    new_catalog: dict = {}
+    # import master catalog list
+    data = CatalogCompare.get_master_catalogs(api=api)
+    # sort master catalogue list
+    catalogues = data["catalogs"]
+    catalogues.sort(key=operator.itemgetter("title"))
+    for i, catalog in enumerate(catalogues):
+        index = i + 1
+        # print each catalog in the master catalog list
+        print(f'{index}: {catalog["title"]}')
+        menu_counter.append(i)
+    # set status to False to run loop
+    status: bool = False
+    while not status:
+        # select catalog to run diagnostic
+        value = click.prompt(
+            "Please enter the number of the catalog you would like to run diagnostics on",
+            type=int,
+        )
+        # check if value exist that is selected
+        if value < min(menu_counter) or value > max(menu_counter):
+            print("That is not a valid selection, please try again")
+        else:
+            status = True
+    with job_progress:
+        # choose catalog to run diagnostics on
+        for i, catalog in enumerate(catalogues):
+            index = i + 1
+            short_title = catalog["defaultName"]
+            if index == value and catalog["downloadURL"]:
+                cat_uuid = catalog["uuid"]
+                download_url = catalog["downloadURL"]
+                break
+
+        # add task for retrieving new catalog
+        retrieving_new_catalog = job_progress.add_task(
+            f"[#f8b737]Retrieving selected catalog ({short_title}) from RegScale.com/resources.", total=1
+        )
+        # retrieve new catalog to run diagnostics on
+        new_catalog = get_new_catalog(url=download_url)
+        # update the task as complete
+        job_progress.update(retrieving_new_catalog, advance=1)
+        # add task for retrieving old catalog
+        retrieving_old_catalog = job_progress.add_task(
+            f"[#f8b737]Retrieving selected catalog ({short_title}) from RegScale application instance.",
+            total=1,
+        )
+        # retrieve old catalog to run diagnostics on
+        old_catalog = get_old_catalog(uuid_value=cat_uuid, api=api)
+        # update the task as complete
+        job_progress.update(retrieving_old_catalog, advance=1)
+        # add task to run diagnostics on new catalog
+        diagnosing_new_catalog = job_progress.add_task(
+            "[#21a5bb]Running diagnostics on catalog from RegScale.com/resources.",
+            total=1,
+        )
+        # run the diagnostics for the new selected catalog
+        new_results = CatalogCompare.run_new_diagnostics(new_diagnose_cat=new_catalog)
+        # update the task as complete
+        job_progress.update(diagnosing_new_catalog, advance=1)
+        # add task to run diagnostics on old catalog
+        diagnosing_old_catalog = job_progress.add_task(
+            "[#21a5bb]Running diagnosing on catalog from RegScale application instance.",
+            total=1,
+        )
+        # run the diagnostics for the old selected catalog
+        old_results = CatalogCompare.run_old_diagnostics(old_diagnose_cat=old_catalog)
+        # update the task as complete
+        job_progress.update(diagnosing_old_catalog, advance=1)
+        # add task to compare catalogs
+        comparing_catalogs = job_progress.add_task(
+            "[#ef5d23]Performing comparison on output of complete catalog diagnostics.",
+            total=1,
+        )
+        # compare catalog results
+        compare_dicts_shallow(dict_1=new_results.dict(), dict_2=old_results.dict(), logger=logger)
+        # update the task as complete
+        job_progress.update(comparing_catalogs, advance=1)
+
+
+def get_old_catalog(uuid_value: str, api: Api) -> dict:
+    """
+    Function to retrieve the old catalog from a RegScale instance via API & GraphQL
+
+    :param str uuid_value: UUID of the catalog to retrieve
+    :param Api api: API object
+    :return: dictionary of the old catalog
+    :rtype: dict
+    """
+    old_catalog_data = {}
+    body = """
+                query {
+                    catalogues(
+                        skip: 0
+                        take: 50
+                        where: { uuid: { eq: "uuid_value" } }
+                    ) {
+                        items {
+                            title
+                            uuid
+                            keywords
+                            securityControls {
+                                id
+                                objectives {
+                                uuid
+                                }
+                                parameters {
+                                uuid
+                                }
+                                cci {
+                                uuid
+                                }
+                                tests {
+                                uuid
+                                }
+                            }
+                        }
+                        pageInfo {
+                        hasNextPage
+                        }
+                        totalCount
+                    }
+                    }
+                    """.replace(
+        "uuid_value", uuid_value
+    )
+    try:
+        old_catalog_data = api.graph(query=body)["catalogues"]["items"][0]
+    except (IndexError, KeyError):
+        error_and_exit(f"Catalog with UUID: {uuid_value} not found in RegScale instance.")
+    return old_catalog_data
+
+
+def compare_dicts_shallow(dict_1: dict, dict_2: dict, logger: logging.Logger) -> None:
+    """
+    Function to compare two dictionaries and output the results
+
+    :param dict dict_1: dictionary to compare
+    :param dict dict_2: dictionary to compare
+    :param logging.Logger logger: logger to use for console outputs
+    :rtype: None
+    """
+    comparison = {
+        "title": "Catalog Titles",
+        "uuid": "Catalog UUIDs",
+        "keywords": "Catalog Keywords",
+        "cci_count": "CCI Counts",
+        "objective_count": "Objective Counts",
+        "parameter_count": "Parameter Counts",
+        "security_control_count": "Security Control Counts",
+        "test_count": "Test Counts",
+    }
+    for key, value in comparison.items():
+        if dict_1.get(key) != dict_2.get(key):
+            logger.info(f"{value} are not the same.")
+        else:
+            logger.info(f"{value} match.")

regscale/core/app/utils/catalog_utils/diagnostic_catalog.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Add functionality to diagnose catalog via API."""
+
+# Standard Imports
+import logging
+import operator
+from typing import Optional
+
+import click  # type: ignore
+import requests  # type: ignore
+from pathlib import Path
+
+from regscale.core.app.utils.app_utils import save_data_to
+from regscale.core.app.utils.catalog_utils.common import get_new_catalog
+from regscale.models.app_models.catalog_compare import CatalogCompare
+
+
+def display_menu() -> None:
+    """
+    Display menu for catalog diagnostic and start the diagnostic process
+
+    :rtype: None
+    """
+    # set environment and application configuration
+    from regscale.core.app.api import Api
+
+    api = Api()
+    api.timeout = 180
+
+    # create logger function to log to the console
+    logger = api.logger
+    menu_counter: list = []
+    download_url: str = ""
+    # import master catalog list
+    data = CatalogCompare.get_master_catalogs(api=api)
+    # sort master catalogue list
+    catalogues = data["catalogs"]
+    catalogues.sort(key=operator.itemgetter("title"))
+    for i, catalog in enumerate(catalogues):
+        index = i + 1
+        # print each catalog in the master catalog list
+        print(f'{index}: {catalog["title"]}')
+        menu_counter.append(index)
+    # set status to False to run loop
+    status: bool = False
+    value: Optional[int] = None
+    while not status:
+        # select catalog to run diagnostic
+        value = click.prompt(
+            "Please enter the number of the catalog you would like to run diagnostics on",
+            type=int,
+        )
+        # check if value exist that is selected
+        if value < min(menu_counter) or value > max(menu_counter):
+            print("That is not a valid selection, please try again")
+        else:
+            status = True
+    # choose catalog to run diagnostics on
+    for i, catalog in enumerate(catalogues):
+        index = i + 1
+        if index == value and catalog["downloadURL"]:
+            download_url = catalog["downloadURL"]
+            break
+    # retrieve new catalog to run diagnostics on
+    new_catalog = get_new_catalog(url=download_url)
+    # run the diagnostic output for the selected catalog
+    save_data_to(
+        file=Path("diagnostics.json"),
+        data=run_diagnostics(diagnose_cat=new_catalog, logger=logger).dict(),
+    )
+
+
+def run_diagnostics(diagnose_cat: dict, logger: logging.Logger) -> CatalogCompare:
+    """
+    Function to run diagnostics on a catalog
+
+    :param dict diagnose_cat: dictionary of a catalog to run diagnostics on
+    :param logging.Logger logger: Logger to log to the console
+    :return: CatalogCompare object
+    :rtype: CatalogCompare
+    """
+    diagnostic_results = CatalogCompare().run_new_diagnostics(diagnose_cat)
+
+    # print information to the terminal
+    logger.info("The catalog you have selected for diagnostics is:")
+    logger.info(diagnostic_results.title)
+    logger.info("The uuid for this catalog is:")
+    logger.info(diagnostic_results.uuid)
+    logger.info("The list of contained keywords in this catalog is:")
+    logger.info(diagnostic_results.keywords)
+    logger.info(f"The number of CCIs in this catalog is: {diagnostic_results.cci_count}")
+    logger.info(f"The number of Objectives in this catalog is: {diagnostic_results.objective_count}")
+    logger.info(f"The number of Parameters in this catalog is: {diagnostic_results.parameter_count}")
+    logger.info(f"The number of Security Controls in this catalog is: {diagnostic_results.security_control_count}")
+    logger.info(f"The number of Tests in this catalog is: {diagnostic_results.test_count}")
+    return diagnostic_results

regscale/core/app/utils/catalog_utils/download_catalog.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Add functionality to download a catalog via API."""
+import json.decoder
+
+# Standard Imports
+import operator
+from pathlib import Path
+from typing import Optional, Tuple
+
+import click  # type: ignore
+import requests  # type: ignore
+
+from regscale.core.app.api import Api
+from regscale.core.app.application import Application
+from regscale.core.app.utils.app_utils import save_data_to
+from regscale.core.app.utils.catalog_utils.common import get_new_catalog, is_valid_url
+from regscale.models.app_models.catalog_compare import CatalogCompare
+
+MENU_COUNTER: list = []
+
+
+def pull_catalogs() -> list[dict]:
+    """
+    Function to pull the master catalogs from the API
+
+    :rtype: list[dict]
+    :return: The list of master catalogs
+    """
+    api = Api()
+    data = CatalogCompare.get_master_catalogs(api=api)
+    # sort master catalog list
+    catalogues = data["catalogs"]
+    catalogues.sort(key=operator.itemgetter("title"))
+    return catalogues
+
+
+def display_menu(show_menu: bool) -> int:
+    """
+    Function to display the menu for the catalog export and handle exporting the selected catalog
+
+    :param bool show_menu: Show the menu
+    :rtype: int
+    :return: The max index + 1 of the menu (one based for real world)
+    """
+    api = Api()
+    catalogues = pull_catalogs()
+    # set environment and application configuration
+    api.timeout = 180
+    # import master catalog list
+    for i, catalog in enumerate(catalogues):
+        if show_menu:
+            print(f'{i + 1}: {catalog["title"]}')
+        MENU_COUNTER.append(i)
+    return max(MENU_COUNTER)
+
+
+def select_catalog(catalog_index: int, logging: bool = True) -> Tuple[dict, dict]:
+    """
+    Function to download the selected catalog
+
+    :param int catalog_index: Index of the selected catalog
+    :param bool logging: Enable logging
+    :rtype: Tuple[dict, dict]
+    :return: The new catalog as a dictionary and the registry dict of the selected catalog
+    """
+    catalogues = pull_catalogs()
+    new_catalog = None
+    registry_item = None
+    app = Application()
+    logger = app.logger
+    status: bool = False
+    value: Optional[int] = None
+    download_url: str = ""
+    catalog_name: str = ""
+    while not status:
+        if catalog_index == 0:
+            value = click.prompt(
+                "Please enter the number of the catalog you would like to download",
+                type=int,
+            )
+        else:
+            value = catalog_index
+        if MENU_COUNTER and value < min(MENU_COUNTER) or MENU_COUNTER and value > max(MENU_COUNTER):
+            print("That is not a valid selection, please try again")
+        else:
+            status = True
+    # Choose catalog to export
+    for i, catalog in enumerate(catalogues):
+        if i + 1 == value and catalog["url"]:
+            registry_item = catalog
+            download_url = catalog["downloadURL"].strip()
+            logger.debug("ix+1: %i, URL: %s", i + 1, download_url)
+            catalog_name = catalog["defaultName"].replace(" ", "_")
+            break
+    if is_valid_url(download_url):
+        new_catalog = get_new_catalog(url=download_url)
+        save_data_to(
+            file=Path(f"{catalog_name}.json"),
+            data=new_catalog,
+            output_log=logging,
+        )
+    return new_catalog, registry_item