regscale-cli 6.27.2.0__py3-none-any.whl → 6.27.3.0__py3-none-any.whl

regscale/core/utils/date.py

@@ -2,8 +2,10 @@
 # -*- coding: utf-8 -*-
 """Utility functions for handling date and datetime conversions"""
 
+import calendar
 import datetime
 import logging
+import re
 from typing import Any, List, Optional, Union
 
 
@@ -39,7 +41,8 @@ def date_str(date_object: Union[str, datetime.datetime, datetime.date, None], da
             return date_object.strftime(date_format)
 
         return date_object.isoformat()
-    except Exception:
+    except (AttributeError, TypeError, ValueError) as e:
+        logger.debug(f"Error converting date object to string: {e}")
         return ""
 
 
@@ -82,6 +85,7 @@ def date_obj(date_str: Union[str, datetime.datetime, datetime.date, int, None])
 def datetime_obj(date_str: Union[str, datetime.datetime, datetime.date, int, None]) -> Optional[datetime.datetime]:
     """
     Convert a string, datetime, date, integer, or timestamp string to a datetime object.
+    If the day of the month is invalid (e.g., November 31), adjusts to the last valid day of that month.
 
     :param Union[str, datetime.datetime, datetime.date, int, None] date_str: The value to convert.
     :return: The datetime object.
@@ -93,6 +97,10 @@ def datetime_obj(date_str: Union[str, datetime.datetime, datetime.date, int, Non
         try:
             return parse(date_str)
         except ParserError as e:
+            # Try to fix invalid day of month (e.g., 2023/11/31 -> 2023/11/30)
+            if fixed_date := _fix_invalid_day_of_month(date_str):
+                return fixed_date
+
             if date_str and str(date_str).lower() not in ["n/a", "none"]:
                 logger.warning(f"Warning could not parse date string: {date_str}\n{e}")
             return None
@@ -105,6 +113,74 @@ def datetime_obj(date_str: Union[str, datetime.datetime, datetime.date, int, Non
     return None
 
 
+def _parse_date_components(match_groups: tuple) -> tuple[int, int, int]:
+    """
+    Parse year, month, day from regex match groups.
+
+    :param tuple match_groups: Tuple of matched groups from regex
+    :return: Tuple of (year, month, day)
+    :rtype: tuple[int, int, int]
+    """
+    if len(match_groups[0]) == 4:  # First group is year (YYYY/MM/DD)
+        return int(match_groups[0]), int(match_groups[1]), int(match_groups[2])
+    # Last group is year (MM/DD/YYYY)
+    return int(match_groups[2]), int(match_groups[0]), int(match_groups[1])
+
+
+def _adjust_invalid_day(year: int, month: int, day: int) -> Optional[datetime.datetime]:
+    """
+    Adjust invalid day of month to last valid day.
+
+    :param int year: Year
+    :param int month: Month
+    :param int day: Day
+    :return: Adjusted datetime or None if invalid
+    :rtype: Optional[datetime.datetime]
+    """
+    last_valid_day = calendar.monthrange(year, month)[1]
+    if day <= last_valid_day:
+        return None
+
+    logger.warning(f"Invalid day {day} for month {month}/{year}. Adjusting to last valid day: {last_valid_day}")
+    try:
+        return datetime.datetime(year, month, last_valid_day)
+    except ValueError:
+        return None
+
+
+def _fix_invalid_day_of_month(date_str: str) -> Optional[datetime.datetime]:
+    """
+    Attempt to fix an invalid day of month in a date string.
+    For example, 2023/11/31 would become 2023/11/30.
+
+    :param str date_str: The date string to fix
+    :return: A datetime object with a valid day, or None if it can't be fixed
+    :rtype: Optional[datetime.datetime]
+    """
+    try:
+        patterns = [
+            r"(\d{4})[/-](\d{1,2})[/-](\d{1,2})",  # YYYY/MM/DD or YYYY-MM-DD
+            r"(\d{1,2})[/-](\d{1,2})[/-](\d{4})",  # MM/DD/YYYY or MM-DD-YYYY
+        ]
+
+        for pattern in patterns:
+            if not (match := re.search(pattern, date_str)):
+                continue
+
+            year, month, day = _parse_date_components(match.groups())
+
+            if not (1 <= month <= 12):
+                continue
+
+            if result := _adjust_invalid_day(year, month, day):
+                return result
+
+        return None
+    except (ValueError, TypeError, AttributeError, IndexError) as e:
+        logger.debug(f"Could not fix invalid day of month for: {date_str} - {e}")
+        return None
+
+
 def time_str(time_obj: Union[str, datetime.datetime, datetime.time]) -> str:
     """
     Convert a datetime/time object to a string.

regscale/integrations/commercial/aws/scanner.py

@@ -707,7 +707,10 @@ Description: {description if isinstance(description, str) else ''}"""
         aws_secret_key_id = kwargs.get("aws_access_key_id") or os.getenv("AWS_ACCESS_KEY_ID")
         aws_secret_access_key = kwargs.get("aws_secret_access_key") or os.getenv("AWS_SECRET_ACCESS_KEY")
         region = kwargs.get("region") or os.getenv("AWS_REGION")
-        if not aws_secret_key_id or not aws_secret_access_key:
+        profile = kwargs.get("profile")
+
+        # Profile or credentials required
+        if not profile and (not aws_secret_key_id or not aws_secret_access_key):
             raise ValueError(
                 "AWS Access Key ID and Secret Access Key are required.\nPlease update in environment "
                 "variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) or pass as arguments."

regscale/integrations/commercial/synqly/query_builder.py

@@ -353,13 +353,16 @@ def _display_filter_result(provider: str, filters: List[str]):
     for i, filter_str in enumerate(filters, 1):
         click.echo(f"  {i}. {filter_str}")
 
+    connector = provider.split("_")[0]
+    filter_flag = "asset_filter" if connector == "vulnerabilities" else "filter"
+
     click.echo("\nComplete command:")
     provider_name = provider.replace(provider.split("_")[0] + "_", "")
 
     # Build command with semicolon-separated filters
     if filters:
         filter_string = ";".join(filters)
-        filter_option = f'--filter "{filter_string}"'
+        filter_option = f'--{filter_flag} "{filter_string}"'
     else:
         filter_option = ""
 

regscale/integrations/control_matcher.py

@@ -7,7 +7,7 @@ across different RegScale entities based on control ID strings.
 
 import logging
 import re
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional, Tuple
 
 from regscale.core.app.api import Api
 from regscale.core.app.application import Application
@@ -42,14 +42,15 @@ class ControlMatcher:
         self._catalog_cache: Dict[int, List[SecurityControl]] = {}
         self._control_impl_cache: Dict[Tuple[int, str], Dict[str, ControlImplementation]] = {}
 
-    def parse_control_id(self, control_string: str) -> Optional[str]:
+    @staticmethod
+    def parse_control_id(control_string: str) -> Optional[str]:
         """
         Parse a control ID string and extract the standardized control identifier.
 
         Handles various formats:
-        - NIST format: AC-1, AC-1(1), AC-1.1
+        - NIST format: AC-1, AC-1(1), AC-1.1, AC-1(a), AC-1.a
         - With leading zeros: AC-01, AC-17(02)
-        - With spaces: AC-1 (1), AC-02 (04)
+        - With spaces: AC-1 (1), AC-02 (04), AC-1 (a)
         - With text: "Access Control AC-1"
         - Multiple controls: "AC-1, AC-2"
 
@@ -64,12 +65,12 @@ class ControlMatcher:
         control_string = control_string.strip().upper()
 
         # Common NIST control ID pattern
-        # Matches: AC-1, AC-01, AC-1(1), AC-1(01), AC-1 (1), AC-1.1, AC-1.01, etc.
+        # Matches: AC-1, AC-01, AC-1(1), AC-1(01), AC-1 (1), AC-1.1, AC-1.01, AC-1(a), AC-1.a, etc.
         # Allows optional whitespace before and inside parentheses
-        pattern = r"([A-Z]{2,3}-\d+(?:\s*\(\s*\d+\s*\)|\.\d+)?)"
+        # Now includes letter parts (a, b, c) in addition to numeric parts
+        pattern = r"([A-Z]{2,3}-\d+(?:\s*\(\s*(?:\d+|[A-Z])\s*\)|\.(?:\d+|[A-Z]))?)"
 
-        matches = re.findall(pattern, control_string)
-        if matches:
+        if matches := re.findall(pattern, control_string):
             # Normalize parentheses to dots for consistency and remove spaces
             control_id = matches[0]
             control_id = control_id.replace(" ", "")  # Remove all spaces
@@ -84,7 +85,9 @@ class ControlMatcher:
                 if "." in number_part:
                     main_num, enhancement = number_part.split(".", 1)
                     main_num = str(int(main_num))
-                    enhancement = str(int(enhancement))
+                    # Only normalize if enhancement is numeric, preserve letters as-is
+                    if enhancement.isdigit():
+                        enhancement = str(int(enhancement))
                     control_id = f"{family}-{main_num}.{enhancement}"
                 else:
                     main_num = str(int(number_part))
@@ -295,6 +298,64 @@ class ControlMatcher:
             main_num = str(int(number_part))
             return f"{family}-{main_num}"
 
+    @staticmethod
+    def _generate_simple_variations(family: str, main_num: str) -> set:
+        """
+        Generate variations for simple control IDs without enhancements.
+
+        :param str family: Control family (e.g., AC, SI)
+        :param str main_num: Main control number
+        :return: Set of variations
+        :rtype: set
+        """
+        main_int = int(main_num)
+        return {
+            f"{family}-{main_int}",
+            f"{family}-{main_int:02d}",
+        }
+
+    @staticmethod
+    def _generate_letter_enhancement_variations(family: str, main_num: str, enhancement: str) -> set:
+        """
+        Generate variations for control IDs with letter-based enhancements.
+
+        :param str family: Control family (e.g., AC, SI)
+        :param str main_num: Main control number
+        :param str enhancement: Letter enhancement (e.g., a, b)
+        :return: Set of variations
+        :rtype: set
+        """
+        main_int = int(main_num)
+        variations = set()
+
+        for main_fmt in [str(main_int), f"{main_int:02d}"]:
+            variations.add(f"{family}-{main_fmt}.{enhancement}")
+            variations.add(f"{family}-{main_fmt}({enhancement})")
+
+        return variations
+
+    @staticmethod
+    def _generate_numeric_enhancement_variations(family: str, main_num: str, enhancement: str) -> set:
+        """
+        Generate variations for control IDs with numeric enhancements.
+
+        :param str family: Control family (e.g., AC, SI)
+        :param str main_num: Main control number
+        :param str enhancement: Numeric enhancement
+        :return: Set of variations
+        :rtype: set
+        """
+        main_int = int(main_num)
+        enh_int = int(enhancement)
+        variations = set()
+
+        for main_fmt in [str(main_int), f"{main_int:02d}"]:
+            for enh_fmt in [str(enh_int), f"{enh_int:02d}"]:
+                variations.add(f"{family}-{main_fmt}.{enh_fmt}")
+                variations.add(f"{family}-{main_fmt}({enh_fmt})")
+
+        return variations
+
     def _get_control_id_variations(self, control_id: str) -> set:
         """
         Generate all valid variations of a control ID (with and without leading zeros).
@@ -302,6 +363,7 @@ class ControlMatcher:
         Examples:
         - AC-1 -> {AC-1, AC-01}
         - AC-17.2 -> {AC-17.2, AC-17.02, AC-17(2), AC-17(02)}
+        - AC-1.a -> {AC-1.a, AC-01.a, AC-1(a), AC-01(a)}
 
         :param str control_id: The control ID to generate variations for
         :return: Set of all valid variations
@@ -311,8 +373,6 @@ class ControlMatcher:
         if not parsed:
             return set()
 
-        variations = set()
-
         # Split by '-' to get family and number parts
         parts = parsed.split("-")
         if len(parts) != 2:
@@ -324,19 +384,14 @@ class ControlMatcher:
         # Handle enhancement notation
         if "." in number_part:
             main_num, enhancement = number_part.split(".", 1)
-            main_int = int(main_num)
-            enh_int = int(enhancement)
-
-            # Generate all combinations: with/without leading zeros, dot/parenthesis notation
-            for main_fmt in [str(main_int), f"{main_int:02d}"]:
-                for enh_fmt in [str(enh_int), f"{enh_int:02d}"]:
-                    variations.add(f"{family}-{main_fmt}.{enh_fmt}")
-                    variations.add(f"{family}-{main_fmt}({enh_fmt})")
+
+            # Check if enhancement is a letter (a, b, c, etc.) or a number
+            if enhancement.isalpha():
+                variations = self._generate_letter_enhancement_variations(family, main_num, enhancement)
+            else:
+                variations = self._generate_numeric_enhancement_variations(family, main_num, enhancement)
         else:
-            # Just main control number
-            main_int = int(number_part)
-            variations.add(f"{family}-{main_int}")
-            variations.add(f"{family}-{main_int:02d}")
+            variations = self._generate_simple_variations(family, number_part)
 
         # Add uppercase versions to ensure consistency
         return {v.upper() for v in variations}