regscale-cli 6.16.0.0__py3-none-any.whl

regscale/integrations/commercial/opentext/click.py

@@ -0,0 +1,99 @@
+"""
+This module contains the Click commands for the opentext integration.
+"""
+
+# pylint: disable=W0621
+
+from datetime import datetime
+from os import PathLike
+from typing import Optional
+
+import click
+from pathlib import Path
+
+from regscale.integrations.commercial.opentext.scanner import WebInspect
+from regscale.models.integration_models.flat_file_importer import FlatFileImporter
+
+
+@click.group()
+def fortify():
+    """Performs actions on the OpenText Fortify"""
+
+
+@fortify.group(name="web_inspect")
+def web_inspect():
+    """Performs actions on the OpenText Web Inspect files."""
+
+
+@web_inspect.command(name="import_file")
+@FlatFileImporter.common_scanner_options(
+    message="File path to the folder containing Fortify WebInspect .xml files to process to RegScale.",
+    prompt="File path for Web Inspect files",
+    import_name="web_inspect",
+)
+def import_file(
+    folder_path: PathLike[str],
+    regscale_ssp_id: int,
+    scan_date: datetime,
+    mappings_path: Path,
+    disable_mapping: bool,
+    s3_bucket: str,
+    s3_prefix: str,
+    aws_profile: str,
+    upload_file: bool,
+):
+    """
+    Import and process a folder of Fortify WebInspect XML file(s).
+    """
+    import_opentext_file(
+        folder_path=folder_path,
+        regscale_ssp_id=regscale_ssp_id,
+        scan_date=scan_date,
+        mappings_path=mappings_path,
+        disable_mapping=disable_mapping,
+        s3_bucket=s3_bucket,
+        s3_prefix=s3_prefix,
+        aws_profile=aws_profile,
+        upload_file=upload_file,
+    )
+
+
+def import_opentext_file(
+    folder_path: PathLike[str],
+    regscale_ssp_id: int,
+    scan_date: datetime,
+    mappings_path: Optional[Path] = None,
+    disable_mapping: Optional[bool] = False,
+    s3_bucket: Optional[str] = None,
+    s3_prefix: Optional[str] = None,
+    aws_profile: Optional[str] = None,
+    upload_file: Optional[bool] = True,
+) -> None:
+    """
+    Import and process a folder of Fortify WebInspect XML file(s).
+
+    :param click.Path folder_path: The Path to a folder of XML file(s) to import
+    :param int regscale_ssp_id: RegScale SSP ID
+    :param datetime scan_date: The date of the scan
+    :param Optional[Path] mappings_path: Path to the header mapping file, default: None
+    :param Optional[bool] disable_mapping: Disable the header mapping, default: False
+    :param Optional[str] s3_bucket: S3 bucket to download scan files from, default: None
+    :param Optional[str] s3_prefix: Prefix (folder path) within the S3 bucket, default: None
+    :param Optional[str] aws_profile: AWS profile to use for S3 access, default: None
+    :param Optional[bool] upload_file: Whether to upload the file to RegScale after processing, default: True
+    :return: None
+    """
+    FlatFileImporter.import_files(
+        import_type=WebInspect,
+        import_name="Web Inspect",
+        file_types=".xml",
+        folder_path=folder_path,
+        regscale_ssp_id=regscale_ssp_id,
+        scan_date=scan_date,
+        mappings_path=mappings_path,
+        disable_mapping=disable_mapping,
+        s3_bucket=s3_bucket,
+        s3_prefix=s3_prefix,
+        aws_profile=aws_profile,
+        upload_file=upload_file,
+    )

regscale/integrations/commercial/opentext/scanner.py

@@ -0,0 +1,143 @@
+"""
+Web inspect Scanner Class
+"""
+
+import logging
+from typing import Iterator
+from typing import List, Optional
+
+from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding
+from regscale.models import ImportValidater
+from regscale.models import IssueSeverity, IssueStatus, regscale_models
+from regscale.models.integration_models.flat_file_importer import FlatFileImporter
+
+logger = logging.getLogger("regscale")
+XML = "*.xml"
+
+
+class WebInspect(FlatFileImporter):
+    finding_severity_map = {
+        4: regscale_models.IssueSeverity.Critical,
+        3: regscale_models.IssueSeverity.High,
+        2: regscale_models.IssueSeverity.Moderate,
+        1: regscale_models.IssueSeverity.Low,
+        0: regscale_models.IssueSeverity.NotAssigned,
+    }
+
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", "Web Inspect")
+        self.required_headers = [
+            "Issues",
+        ]
+        self.mapping_file = kwargs.get("mappings_path")
+        self.disable_mapping = kwargs.get("disable_mapping")
+        self.validater = ImportValidater(
+            self.required_headers, kwargs.get("file_path"), self.mapping_file, self.disable_mapping, xml_tag="Scan"
+        )
+        self.headers = self.validater.parsed_headers
+        self.mapping = self.validater.mapping
+        data = self.mapping.get_value(self.validater.data, "Issues", {}).get("Issue", [])
+        vuln_count = 0
+        for item in data:
+            severity_int = int(item.get("Severity", 0))
+            severity = self.finding_severity_map.get(severity_int, IssueSeverity.NotAssigned)
+
+            if severity in (IssueSeverity.High, IssueSeverity.Moderate, IssueSeverity.Low):
+                vuln_count += 1
+        super().__init__(
+            logger=logger,
+            headers=self.headers,
+            asset_func=self.create_asset,
+            vuln_func=self.create_vuln,
+            extra_headers_allowed=True,
+            finding_severity_map=self.finding_severity_map,
+            asset_count=len(data),
+            vuln_count=vuln_count,
+            **kwargs,
+        )
+
+    def create_asset(self, *args, **kwargs) -> Iterator[IntegrationAsset]:
+        """
+        Fetches assets from the processed XML files
+
+        :yields: Iterator[IntegrationAsset]
+        """
+        # Get a list of issues from xml node Issues
+        if data := self.mapping.get_value(self.validater.data, "Issues", {}):
+            issues_dict = data.get("Issue", [])
+            for issue in issues_dict:
+                yield from self.parse_asset(issue)
+
+    def parse_asset(self, issue: dict) -> Iterator[IntegrationAsset]:
+        """
+        Parse the asset from an element
+
+        :param dict issue: The Issue element
+        :yields: IntegrationAsset
+        """
+        host = issue.get("Host")
+        if host:
+            yield IntegrationAsset(name=host, asset_type="Other", asset_category="Hardware", identifier=host)
+
+    def create_vuln(self, *args, **kwargs) -> Iterator[IntegrationFinding]:
+        """
+        Fetches findings from the XML files
+
+        :return: A list of findings
+        :rtype: List[IntegrationFinding]
+        """
+        # Get a list of issues from xml node Issues
+        if data := self.mapping.get_value(self.validater.data, "Issues", {}):
+            issues_dict = data.get("Issue", [])
+            for issue in issues_dict:
+                if res := self.parse_finding(issue):
+                    yield res
+
+    @staticmethod
+    def _parse_report_section(sections: List[dict], section_name: str) -> str:
+        """
+        Extract text from a specific report section.
+
+        :param List[dict] sections: List of report sections
+        :param str section_name: Name of the section to extract text from
+        :return: Text from the specified section
+        :rtype: str
+        """
+        return next((section.get("SectionText", "") for section in sections if section.get("Name") == section_name), "")
+
+    def parse_finding(self, issue: dict) -> Optional[IntegrationFinding]:
+        """
+        Parse the dict to an Integration Finding
+
+        :param dict issue: The Issue element
+        :returns The Integration Finding
+        :rtype Optional[IntegrationFinding]
+        """
+        severity_int = int(issue.get("Severity", 3))
+        severity = self.finding_severity_map.get(severity_int, IssueSeverity.High)
+        title = issue.get("Name", "")
+        host = issue.get("Host", "")
+        plugin_id = issue.get("VulnerabilityID", "")
+        external_id = str(host + plugin_id)
+        sections = issue.get("ReportSection")
+        description = self._parse_report_section(sections, "Summary")
+        mitigation = self._parse_report_section(sections, "Fix")
+
+        if severity in (IssueSeverity.Critical, IssueSeverity.High, IssueSeverity.Moderate, IssueSeverity.Low):
+            return IntegrationFinding(
+                external_id=external_id,
+                asset_identifier=host,
+                control_labels=[],
+                description=description,
+                status=IssueStatus.Open,
+                title=title,
+                severity=severity,
+                severity_int=severity_int,
+                category=f"{self.name} Vulnerability",
+                plugin_id=plugin_id,
+                plugin_name=title,
+                rule_id=plugin_id,
+                recommendation_for_mitigation=mitigation,
+                source_report=self.name,
+            )
+        return None

regscale/integrations/commercial/prisma.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Prisma RegScale integration"""
+from datetime import datetime
+from os import PathLike
+from typing import Optional
+
+import click
+from pathlib import Path
+
+from regscale.models.integration_models.flat_file_importer import FlatFileImporter
+from regscale.models.integration_models.prisma import Prisma
+
+
+@click.group()
+def prisma():
+    """Performs actions on Prisma export files."""
+
+
+@prisma.command(name="import_prisma")
+@FlatFileImporter.common_scanner_options(
+    message="File path to the folder containing Nexpose .csv files to process to RegScale.",
+    prompt="File path for Prisma files",
+    import_name="prisma",
+)
+def import_prisma(
+    folder_path: PathLike[str],
+    regscale_ssp_id: int,
+    scan_date: datetime,
+    mappings_path: PathLike[str],
+    disable_mapping: bool,
+    s3_bucket: str,
+    s3_prefix: str,
+    aws_profile: str,
+    upload_file: bool,
+):
+    """
+    Import scans, vulnerabilities and assets to RegScale from Prisma export files
+    """
+    import_prisma_data(
+        folder_path=folder_path,
+        regscale_ssp_id=regscale_ssp_id,
+        scan_date=scan_date,
+        mappings_path=mappings_path,
+        disable_mapping=disable_mapping,
+        s3_bucket=s3_bucket,
+        s3_prefix=s3_prefix,
+        aws_profile=aws_profile,
+        upload_file=upload_file,
+    )
+
+
+def import_prisma_data(
+    folder_path: PathLike[str],
+    regscale_ssp_id: int,
+    scan_date: datetime,
+    s3_bucket: str,
+    s3_prefix: str,
+    aws_profile: str,
+    mappings_path: Optional[PathLike[str]] = None,
+    disable_mapping: bool = False,
+    upload_file: Optional[bool] = True,
+) -> None:
+    """
+    Import Prisma data to RegScale
+
+    :param PathLike[str] folder_path: Path to the folder containing Prisma .csv files
+    :param int regscale_ssp_id: RegScale System Security Plan ID
+    :param datetime scan_date: Date of the scan
+    :param str s3_bucket: S3 bucket to download the files from
+    :param str s3_prefix: S3 prefix to download the files from
+    :param str aws_profile: AWS profile to use for S3 access
+    :param Optional[Path] mappings_path: Path to the header mapping file, defaults to None
+    :param bool disable_mapping: Whether to disable custom mapping, defaults to False
+    :param Optional[bool] upload_file: Whether to upload the file to RegScale after processing, defaults to True
+    :rtype: None
+    """
+    FlatFileImporter.import_files(
+        import_type=Prisma,
+        import_name="Prisma",
+        file_types=".csv",
+        folder_path=folder_path,
+        regscale_ssp_id=regscale_ssp_id,
+        scan_date=scan_date,
+        mappings_path=mappings_path,
+        disable_mapping=disable_mapping,
+        s3_bucket=s3_bucket,
+        s3_prefix=s3_prefix,
+        aws_profile=aws_profile,
+        upload_file=upload_file,
+    )