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

regscale/models/integration_models/ecr_models/ecr.py

@@ -2,39 +2,45 @@
 ECR Scan information
 """
 
-import json
-from pathlib import Path
-from typing import Any, List, Optional, Sequence, Union
+from typing import List, Optional, Union
 
 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, is_valid_fqdn
-from regscale.exceptions import ValidationException
+from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding
 from regscale.models import ImportValidater
 from regscale.models.integration_models.flat_file_importer import FlatFileImporter
+from regscale.models.regscale_models import AssetStatus, IssueSeverity, IssueStatus
 from regscale.models.regscale_models.asset import Asset
-from regscale.models.regscale_models.vulnerability import Vulnerability
 
 
 class ECR(FlatFileImporter):
     """ECR Scan information"""
 
     def __init__(self, **kwargs):
-        self.name = kwargs.get("name")
-        self.vuln_title = "name"
-        self.fmt = "%m/%d/%y"
-        self.dt_format = "%Y-%m-%d %H:%M:%S"
-        self.image_name = "Name"
-        self.raw_dict = {}
-        self.required_headers = [
-            self.image_name,
-        ]
-        self.mapping_file = kwargs.get("mappings_path")
-        self.disable_mapping = kwargs.get("disable_mapping")
-        self.file_type = kwargs.get("file_type")
-        keys = ["imageScanFindings", "findings"] if self.file_type == ".json" else None
+        # Group related attributes to reduce instance attribute count
+        self.scanner_config = {
+            "name": kwargs.get("name"),
+            "vuln_title": "name",
+            "fmt": "%m/%d/%y",
+            "dt_format": "%Y-%m-%d %H:%M:%S",
+            "image_name": "Name",
+        }
+        self.mapping_config = {
+            "mapping_file": kwargs.get("mappings_path"),
+            "disable_mapping": kwargs.get("disable_mapping"),
+        }
+        self.file_config = {
+            "file_type": kwargs.get("file_type"),
+            "raw_dict": {},
+        }
+        self.required_headers = [self.scanner_config["image_name"]]
+        keys = ["imageScanFindings", "findings"] if self.file_config["file_type"] == ".json" else None
         self.validater = ImportValidater(
-            self.required_headers, kwargs.get("file_path"), self.mapping_file, self.disable_mapping, keys=keys
+            self.required_headers,
+            kwargs.get("file_path"),
+            self.mapping_config["mapping_file"],
+            self.mapping_config["disable_mapping"],
+            keys=keys,
         )
         self.headers = self.validater.parsed_headers
         self.mapping = self.validater.mapping
@@ -48,92 +54,55 @@ class ECR(FlatFileImporter):
             **kwargs,
         )
 
-    def file_to_list_of_dicts(
-        self,
-    ) -> tuple[Optional[Sequence[str]], Union[dict, list[Any]]]:
+    def create_asset(self, dat: Optional[dict] = None) -> IntegrationAsset:
         """
-        Override the base method: Converts a json or csv file to a list of dictionaries
-
-        :raises ValidationException: If the headers in the csv/xlsx file do not match the expected headers
-        :return: Tuple of header and data from csv file
-        :rtype: tuple[Optional[Sequence[str]], Union[dict, list[Any]]]
-        """
-        header: Optional[Sequence[str]] = []
-        data: dict = {}
-        with open(self.attributes.file_path, encoding="utf-8") as file:
-            if file.name.endswith(".csv"):
-                data, header = self.convert_csv_to_dict(file)
-            elif file.name.endswith(".json"):
-                try:
-                    # Filter possible null values
-                    self.raw_dict = json.load(file)
-                    if not isinstance(self.raw_dict, dict):
-                        raise ValidationException(
-                            f"Invalid JSON file. Must be a dictionary, it is {type(self.raw_dict)}"
-                        )
-                    data = self.raw_dict.get("imageScanFindings", {}).get("findings", [])
-                except json.JSONDecodeError:
-                    raise ValidationException("Invalid JSON file. Encountered a JSONDecodeError.")
-            else:
-                raise ValidationException(
-                    f"Unsupported file type. Must be a .csv or .json file.\nProvided: {self.file_type}"
-                )
-        return header, data
-
-    def create_asset(self, dat: Optional[dict] = None) -> Asset:
-        """
-        Create an asset from a row in the ECR file
+        Create an integration asset from a row in the ECR file
 
         :param Optional[dict] dat: Data row from file, defaults to None
-        :return: RegScale Asset object
-        :rtype: Asset
+        :return: RegScale IntegrationAsset object
+        :rtype: IntegrationAsset
         """
         name = self.mapping.get_value(dat, "Name") or self.mapping.get_value(dat, "name")
-        if repository_name := self.mapping.get_value(dat, "repositoryName", self.raw_dict.get("repositoryName", "")):
-            if (image_id_data := self.raw_dict.get("imageId", {}).get("imageDigest", "").split(":")) and len(
-                image_id_data
-            ) > 1:
+        if repository_name := self.mapping.get_value(
+            dat, "repositoryName", self.file_config["raw_dict"].get("repositoryName", "")
+        ):
+            image_id_data = self.file_config["raw_dict"].get("imageId", {}).get("imageDigest", "").split(":")
+            if image_id_data and len(image_id_data) > 1:
                 image_id = image_id_data[1]
             else:
                 image_id = image_id_data[0]
             name = f"{repository_name}:{image_id}"
 
         # Check if string has a forward slash
-        return Asset(
-            **{
-                "id": 0,
-                "name": name,
-                "description": "Container Image" if name and "/" in name else "",
-                "operatingSystem": "Linux",
-                "operatingSystemVersion": "",
-                "ipAddress": "0.0.0.0",
-                "isPublic": True,
-                "status": "Active (On Network)",
-                "assetCategory": "Software",
-                "bLatestScan": True,
-                "bAuthenticatedScan": True,
-                "scanningTool": self.name,
-                "assetOwnerId": self.config["userId"],
-                "assetType": "Other",
-                "fqdn": name if is_valid_fqdn(name) else None,
-                "systemAdministratorId": self.config["userId"],
-                "parentId": self.attributes.parent_id,
-                "parentModule": self.attributes.parent_module,
-            }
+        return IntegrationAsset(
+            identifier=name,
+            name=name,
+            ip_address="0.0.0.0",
+            cpu=0,
+            ram=0,
+            scanning_tool=self.scanner_config["name"],
+            status=AssetStatus.Active.value,
+            asset_type="Other",
+            asset_category="Software",
+            operating_system="Linux",
         )
 
-    def create_vuln(self, dat: Optional[dict] = None, **kwargs) -> Union[Vulnerability, List[Vulnerability], None]:
+    def create_vuln(
+        self, dat: Optional[dict] = None, **_kwargs
+    ) -> Union[IntegrationFinding, List[IntegrationFinding], None]:
         """
-        Create a vulnerability from a row in the ECR csv file
+        Create a finding from a row in the ECR csv file
 
         :param Optional[dict] dat: Data row from file, defaults to None
-        :return: RegScale Vulnerability object, a list of RegScale Vulnerability objects or None
-        :rtype: Union[Vulnerability, List[Vulnerability], None]
+        :return: RegScale IntegrationFinding object, a list of RegScale IntegrationFinding objects or None
+        :rtype: Union[IntegrationFinding, List[IntegrationFinding], None]
         """
-        vulns: List[Vulnerability] = []
+        vulns: List[IntegrationFinding] = []
         hostname = dat.get("Name") or dat.get("name")
-        if repository_name := self.mapping.get_value(dat, "repositoryName", self.raw_dict.get("repositoryName", "")):
-            image_id_data = self.raw_dict.get("imageId", {}).get("imageDigest", "").split(":")
+        if repository_name := self.mapping.get_value(
+            dat, "repositoryName", self.file_config["raw_dict"].get("repositoryName", "")
+        ):
+            image_id_data = self.file_config["raw_dict"].get("imageId", {}).get("imageDigest", "").split(":")
             if len(image_id_data) > 1:
                 image_id = image_id_data[1]
             else:
@@ -147,89 +116,73 @@ class ECR(FlatFileImporter):
                 return single_vuln
         return vulns
 
-    def get_asset(self, hostname: str) -> Optional[Asset]:
-        """
-        Get the asset by hostname
-
-        :param str hostname: The hostname
-        :return: The asset if found, otherwise None
-        :rtype: Optional[Asset]
-        """
-        asset_match = [asset for asset in self.data["assets"] if asset.name == hostname]
-        return asset_match[0] if asset_match else None
-
-    def create_vulnerability_object(
-        self, asset: Asset, hostname: str, cve: str, severity: str, description: str
-    ) -> Vulnerability:
+    def create_finding(self, finding_data: dict) -> IntegrationFinding:
         """
-        Create a vulnerability from a row in the ECR file
+        Create an IntegrationFinding from finding data
 
-        :param Asset asset: The asset
-        :param str hostname: The hostname
-        :param str cve: The CVE
-        :param str severity: The severity
-        :param str description: The description
-        :return: The vulnerability
-        :rtype: Vulnerability
+        :param dict finding_data: Dictionary containing finding data
+        :return: The IntegrationFinding
+        :rtype: IntegrationFinding
         """
-        config = self.attributes.app.config
-
-        return Vulnerability(
-            id=0,
-            scanId=0,
-            parentId=asset.id,
-            parentModule="assets",
-            ipAddress="0.0.0.0",
-            firstSeen=get_current_datetime(),  # No timestamp on ECR
-            lastSeen=get_current_datetime(),  # No timestamp on ECR
-            daysOpen=None,
-            dns=hostname,
-            mitigated=None,
-            operatingSystem=asset.operatingSystem,
-            severity=severity,
-            plugInName=cve,
-            cve=cve,
-            tenantsId=0,
-            title=f"{cve} on asset {asset.name}",
-            description=cve,
-            plugInText=description,
-            createdById=config["userId"],
-            lastUpdatedById=config["userId"],
-            dateCreated=get_current_datetime(),
+        title = f"{finding_data['cve']} on asset {finding_data['hostname']}"
+        return IntegrationFinding(
+            title=title,
+            dns=finding_data["hostname"],
+            description=finding_data["cve"],
+            severity=self.determine_severity(finding_data["severity"]),
+            status=IssueStatus.Open.value,
+            plugin_name=finding_data["cve"],
+            plugin_id=finding_data["cve"],
+            plugin_text=finding_data["description"],
+            asset_identifier=finding_data["hostname"],
+            cve=finding_data["cve"],
+            first_seen=self.scan_date,
+            last_seen=self.scan_date,
+            scan_date=self.scan_date,
+            category="Software",
+            control_labels=[],
         )
 
-    def process_csv_vulns(self, dat: dict, hostname: str) -> Optional[Vulnerability]:
+    def process_csv_vulns(self, dat: dict, hostname: str) -> Optional[IntegrationFinding]:
         """
         Process the CSV findings from the ECR scan
 
         :param dict dat: The data from the ECR scan
         :param str hostname: The hostname
         :return: The vulnerability or None
-        :rtype: Optional[Vulnerability]
+        :rtype: Optional[IntegrationFinding]
 
         """
         cve = dat.get("CVE", "")
         severity = self.determine_severity(dat.get("Severity", "Info"))
-        if asset := self.get_asset(hostname):
-            return self.create_vulnerability_object(asset, hostname, cve, severity, dat.get("uri", ""))
-        return None
-
-    def process_json_vulns(self, dat: dict, hostname: str) -> List[Vulnerability]:
+        finding_data = {
+            "hostname": hostname,
+            "cve": cve,
+            "severity": severity,
+            "description": dat.get("uri", ""),
+        }
+        return self.create_finding(finding_data)
+
+    def process_json_vulns(self, dat: dict, hostname: str) -> List[IntegrationFinding]:
         """
         Process the JSON findings from the ECR scan
 
         :param dict dat: The data from the ECR scan
         :param str hostname: The hostname
         :return: The list of vulnerabilities
-        :rtype: List[Vulnerability]
+        :rtype: List[IntegrationFinding]
         """
-        vulns: List[Vulnerability] = []
+        vulns: List[IntegrationFinding] = []
         if findings := dat.get("imageScanFindings", {}).get("findings"):
             for finding in findings:
                 cve = finding.get("name")
                 severity = self.determine_severity(finding["severity"])
-                asset = self.get_asset(hostname)
-                if asset:
-                    vuln = self.create_vulnerability_object(asset, hostname, cve, severity, finding.get("uri", ""))
-                    vulns.append(vuln)
+                finding_data = {
+                    "hostname": hostname,
+                    "cve": cve,
+                    "severity": severity,
+                    "description": finding.get("uri", ""),
+                }
+                vuln = self.create_finding(finding_data)
+                vulns.append(vuln)
         return vulns

regscale/models/integration_models/flat_file_importer/__init__.py

@@ -33,7 +33,7 @@ from regscale.core.app.utils.parser_utils import safe_datetime_str
 from regscale.integrations.scanner_integration import ScannerIntegration
 from regscale.models import IssueStatus, Metadata, regscale_models
 from regscale.models.app_models.mapping import Mapping
-from regscale.models.regscale_models import Asset, File, Vulnerability
+from regscale.models.regscale_models import Asset, File, IssueSeverity, Vulnerability
 
 logger = logging.getLogger(__name__)
 
@@ -41,6 +41,10 @@ DT_FORMAT = "%Y-%m-%d"
 
 
 class FlatFileIntegration(ScannerIntegration):
+    """
+    Flat File Integration
+    """
+
     title = "Flat File Integration"
     # Required fields from ScannerIntegration
     asset_identifier_field = "name"
@@ -53,13 +57,6 @@ class FlatFileIntegration(ScannerIntegration):
         finding_severity_map: Optional[dict] = None,
         **kwargs: Any,
     ):
-        """
-        Initialize the FlatFileIntegration
-
-        :param int plan_id: The plan id
-        :param str asset_identifier_field: The asset identifier field to use, defaults to "name"
-        :param dict kwargs: Additional keyword arguments
-        """
         self.asset_identifier_field = asset_identifier_field
         if finding_severity_map:
             self.finding_severity_map = finding_severity_map
@@ -68,6 +65,7 @@ class FlatFileIntegration(ScannerIntegration):
                 "Critical": regscale_models.IssueSeverity.Critical,
                 "High": regscale_models.IssueSeverity.High,
                 "Medium": regscale_models.IssueSeverity.Moderate,
+                "Moderate": regscale_models.IssueSeverity.Moderate,
                 "Low": regscale_models.IssueSeverity.Low,
             }
         super().__init__(plan_id=plan_id, **kwargs)
@@ -126,20 +124,12 @@ class FlatFileImporter(ABC):
                 "Critical": regscale_models.IssueSeverity.Critical,
                 "High": regscale_models.IssueSeverity.High,
                 "Medium": regscale_models.IssueSeverity.Moderate,
+                "Moderate": regscale_models.IssueSeverity.Moderate,
                 "Low": regscale_models.IssueSeverity.Low,
             }
 
-        # Set the parent_id, parent_module, and plan_id if they are not provided
-        if "parent_id" not in kwargs and "object_id" in kwargs:
-            kwargs["parent_id"] = kwargs["object_id"]
-            kwargs["plan_id"] = kwargs["object_id"]
-        if kwargs.get("is_component", False):
-            kwargs["parent_module"] = regscale_models.Component.get_module_string()
-        else:
-            kwargs["parent_module"] = regscale_models.SecurityPlan.get_module_string()
+        kwargs = self.update_kwargs(kwargs)
 
-        if "app" not in kwargs:
-            kwargs["app"] = Application()
         # empty generator
         self.integration_assets: Generator["IntegrationAsset", None, None] = (x for x in [])
         self.integration_findings: Generator["IntegrationAsset", None, None] = (x for x in [])
@@ -209,7 +199,7 @@ class FlatFileImporter(ABC):
             flat_int.num_assets_to_process = len(self.data["assets"])
         if vuln_count:
             flat_int.num_findings_to_process = vuln_count
-        elif isinstance(self.data["vulns"], list):
+        elif isinstance(self.data["vulns"], list) and not vuln_count:
             flat_int.num_findings_to_process = len(self.data["vulns"])
         flat_int.sync_assets(
             plan_id=self.attributes.plan_id,
@@ -229,6 +219,31 @@ class FlatFileImporter(ABC):
         )
         self.clean_up()
 
+    def update_kwargs(self, kwargs: dict) -> dict:
+        """
+        Update the kwargs with the default values
+
+        :param dict kwargs: The kwargs to update
+        :return: The updated kwargs
+        :rtype: dicta
+        """
+        # Set the parent_id, parent_module, and plan_id if they are not provided
+        if "parent_id" not in kwargs and "object_id" in kwargs:
+            kwargs["parent_id"] = kwargs["object_id"]
+            kwargs["plan_id"] = kwargs["object_id"]
+        if kwargs.get("is_component", False):
+            kwargs["parent_module"] = regscale_models.Component.get_module_string()
+        else:
+            kwargs["parent_module"] = regscale_models.SecurityPlan.get_module_string()
+
+        # if plan id is still not set, set it to the object id
+        if "plan_id" not in kwargs or not kwargs["plan_id"]:
+            kwargs["plan_id"] = kwargs["object_id"]
+
+        if "app" not in kwargs:
+            kwargs["app"] = Application()
+        return kwargs
+
     def parse_finding(self, vuln: Union[Vulnerability, "IntegrationFinding"]) -> Optional["IntegrationFinding"]:
         """
         Parses a vulnerability object into an IntegrationFinding object
@@ -240,6 +255,8 @@ class FlatFileImporter(ABC):
         from regscale.integrations.scanner_integration import IntegrationFinding
 
         if isinstance(vuln, IntegrationFinding):
+            # We will store this in the properties subsystem of issue.
+            vuln.extra_data["source_file_path"] = self.attributes.file_path
             return vuln
 
         try:
@@ -543,21 +560,6 @@ class FlatFileImporter(ABC):
                 if asset not in self.data["assets"]:
                     self.data["assets"].append(asset)
 
-    def _check_vuln(self, vuln_to_check: Union[Vulnerability, "IntegrationFinding"]) -> None:
-        """
-        Check if the vuln is in the data
-
-        :param Union[Vulnerability, IntegrationFinding] vuln_to_check: The vulnerability to check to prevent duplicates
-        :rtype: None
-        """
-        from regscale.integrations.scanner_integration import IntegrationFinding
-
-        if isinstance(vuln_to_check, IntegrationFinding):
-            if vuln_to_check not in self.data["vulns"]:
-                self.data["vulns"].append(vuln_to_check)
-        elif (vuln_to_check and vuln_to_check not in self.data["vulns"]) and hasattr(vuln_to_check, "id"):
-            self.data["vulns"].append(vuln_to_check)
-
     def create_vulns(self, func: Callable) -> None:
         """
         Create vulns in RegScale from csv file
@@ -585,11 +587,12 @@ class FlatFileImporter(ABC):
                 if not vuln:
                     vuln_progress.advance(vuln_task, advance=1)
                     continue
-                if isinstance(vuln, Vulnerability) or isinstance(vuln, IntegrationFinding):
-                    self._check_vuln(vuln)
+
+                if isinstance(vuln, IntegrationFinding):
+                    self.data["vulns"].append(vuln)
                 if isinstance(vuln, list):
                     for v in vuln:
-                        self._check_vuln(v)
+                        self.data["vulns"].append(v)
                 if isinstance(vuln, Iterator):
                     self.integration_findings = vuln
                     self.data["vulns"] = vuln
@@ -936,10 +939,21 @@ class FlatFileImporter(ABC):
         :return: The severity
         :rtype: str
         """
+        mapping = {
+            "critical": IssueSeverity.Critical,
+            "high": IssueSeverity.High,
+            "medium": IssueSeverity.Moderate,
+            "moderate": IssueSeverity.Moderate,
+            "low": IssueSeverity.Low,
+            "informational": IssueSeverity.NotAssigned,
+            "none": IssueSeverity.NotAssigned,
+            "info": IssueSeverity.NotAssigned,
+            "unknown": IssueSeverity.NotAssigned,
+        }
         severity = "info"
         if s:
             severity = s.lower()
-        return severity
+        return mapping.get(severity, IssueSeverity.NotAssigned)
 
     @staticmethod
     def map_status_to_issue_status(status: str) -> IssueStatus:

regscale/models/integration_models/ibm.py

@@ -8,9 +8,10 @@ from urllib.parse import urlparse
 from regscale.core.app.application import Application
 from regscale.core.app.logz import create_logger
 from regscale.core.app.utils.app_utils import epoch_to_datetime, get_current_datetime, is_valid_fqdn
-from regscale.models import ImportValidater, Mapping
+from regscale.integrations.scanner_integration import IntegrationAsset, IntegrationFinding
+from regscale.models import ImportValidater
 from regscale.models.integration_models.flat_file_importer import FlatFileImporter
-from regscale.models.regscale_models import Asset, Vulnerability
+from regscale.models.regscale_models import Asset, IssueSeverity, IssueStatus
 
 ISSUE_TYPE = "Issue Type"
 VULNERABILITY_TITLE = ISSUE_TYPE
@@ -53,74 +54,55 @@ class AppScan(FlatFileImporter):
             **kwargs,
         )
 
-    def create_asset(self, dat: Optional[dict] = None) -> Asset:
+    def create_asset(self, dat: Optional[dict] = None) -> IntegrationAsset:
         """
         Create an asset from a row in the IBM csv file
 
         :param Optional[dict] dat: Data row from CSV file, defaults to None
-        :return: RegScale Asset object
-        :rtype: Asset
+        :return: RegScale IntegrationAsset object
+        :rtype: IntegrationAsset
         """
         parsed_url = urlparse(self.mapping.get_value(dat, "URL"))
         hostname: str = f"{parsed_url.scheme}://{parsed_url.netloc}"
-        return Asset(
+        return IntegrationAsset(
             **{
-                "id": 0,
                 "name": hostname,
-                "isPublic": True,
+                "identifier": hostname,
                 "status": "Active (On Network)",
-                "assetCategory": "Software",
-                "bLatestScan": True,
-                "bAuthenticatedScan": True,
-                "scanningTool": self.name,
-                "assetOwnerId": self.config["userId"],
-                "assetType": "Other",
+                "asset_category": "Software",
+                "scanning_tool": self.name,
+                "asset_type": "Other",
                 "fqdn": hostname if is_valid_fqdn(hostname) else None,
-                "systemAdministratorId": self.config["userId"],
-                "parentId": self.attributes.parent_id,
-                "parentModule": self.attributes.parent_module,
             }
         )
 
-    def create_vuln(self, dat: Optional[dict] = None, **kwargs) -> Optional[Vulnerability]:
+    def create_vuln(self, dat: Optional[dict] = None, **kwargs) -> Optional[IntegrationFinding]:
         """
-        Create a vulnerability from a row in the IBM csv file
-
+        Create an IntegrationFinding from a row in the IBM csv file
         :param Optional[dict] dat: Data row from CSV file, defaults to None
-        :return: RegScale Vulnerability object or None
-        :rtype: Optional[Vulnerability]
+        :return: RegScale IntegrationFinding object or None
+        :rtype: Optional[IntegrationFinding]
         """
+
         regscale_vuln = None
         parsed_url = urlparse(self.mapping.get_value(dat, "URL"))
         hostname: str = f"{parsed_url.scheme}://{parsed_url.netloc}"
         description: str = self.mapping.get_value(dat, ISSUE_TYPE)
         app_scan_severity = self.mapping.get_value(dat, "Severity")
         severity = self.severity_map.get(app_scan_severity, "Informational")
-        config = self.attributes.app.config
-        asset_match = [asset for asset in self.data["assets"] if asset.name == hostname]
-        asset = asset_match[0] if asset_match else None
-        if dat and asset_match:
-            regscale_vuln = Vulnerability(
-                id=0,
-                scanId=0,  # set later
-                parentId=asset.id,
-                parentModule="assets",
-                ipAddress="0.0.0.0",  # No ip address available
-                lastSeen=get_current_datetime(),
-                firstSeen=epoch_to_datetime(self.create_epoch),
-                daysOpen=None,
-                dns=hostname,
-                mitigated=None,
-                severity=severity,
-                plugInName=description,
-                cve="",
-                vprScore=None,
-                tenantsId=0,
-                title=description[:255] if description else "No Title",
+        if dat:
+            return IntegrationFinding(
+                title=self.mapping.get_value(dat, self.vuln_title),
                 description=description,
-                plugInText=description,
-                createdById=config["userId"],
-                lastUpdatedById=config["userId"],
-                dateCreated=get_current_datetime(),
+                cve="",
+                severity=self.determine_severity(severity),
+                asset_identifier=hostname,
+                plugin_name=description,
+                plugin_text=description[:255],
+                control_labels=[],
+                category="Hardware",
+                status=IssueStatus.Open,
+                last_seen=get_current_datetime(),
+                first_seen=epoch_to_datetime(self.create_epoch),
             )
         return regscale_vuln