chore: prepare API and UI changelogs for 5.30.1 release (#11566)

Co-authored-by: Josema Camacho <josema@prowler.com>

.env

@@ -145,7 +145,7 @@ SENTRY_RELEASE=local
 NEXT_PUBLIC_SENTRY_ENVIRONMENT=${SENTRY_ENVIRONMENT}
 
 #### Prowler release version ####
-NEXT_PUBLIC_PROWLER_RELEASE_VERSION=v5.30.0
+NEXT_PUBLIC_PROWLER_RELEASE_VERSION=v5.30.1
 
 # Social login credentials
 SOCIAL_GOOGLE_OAUTH_CALLBACK_URL="${AUTH_URL}/api/auth/callback/google"

.github/workflows/ui-e2e-tests-v2.yml

@@ -134,7 +134,17 @@ jobs:
         # docker-compose.yml references prowlercloud/prowler-api:latest from the registry,
         # which lags behind PR changes; build locally so E2E exercises the API image
         # produced by this PR.
-        run: docker build -t prowlercloud/prowler-api:latest ./api
+        #
+        # The image installs the SDK from git@master (api/uv.lock), so a PR changing BOTH the SDK
+        # and the API would run against the OLD SDK and crash on startup. Overlay the checkout's
+        # SDK source so both run together. New SDK dependencies still need an api/uv.lock bump.
+        run: |
+          docker build -t prowlercloud/prowler-api:pr-base ./api
+          docker build -t prowlercloud/prowler-api:latest -f - prowler <<'DOCKERFILE'
+          FROM prowlercloud/prowler-api:pr-base
+          RUN rm -rf /home/prowler/.venv/lib/python3.12/site-packages/prowler
+          COPY --chown=prowler:prowler . /home/prowler/.venv/lib/python3.12/site-packages/prowler
+          DOCKERFILE
 
       - name: Start API services
         run: |

README.md

@@ -122,7 +122,7 @@ Every AWS provider scan will enqueue an Attack Paths ingestion job automatically
 | Vercel | 26 | 6 | 0 | 8 | Official | UI, API, CLI |
 | Okta | 1 | 1 | 0 | 1 | Official | CLI |
 | Scaleway [Contact us](https://prowler.com/contact) | 1 | 1 | 0 | 1 | Unofficial | CLI |
-| StackIT [Contact us](https://prowler.com/contact) | 4 | 1 | 0 | 1 | Unofficial | CLI |
+| StackIT [Contact us](https://prowler.com/contact) | 7 | 2 | 0 | 3 | Unofficial | CLI |
 | NHN | 6 | 2 | 1 | 0 | Unofficial | CLI |
 
 > [!Note]

api/CHANGELOG.md

@@ -2,13 +2,24 @@
 
 All notable changes to the **Prowler API** are documented in this file.
 
-## [1.31.0] (Prowler UNRELEASED)
+## [1.31.1] (Prowler v5.30.1)
+
+### 🐞 Fixed
+
+- `compliance-overviews/attributes` now resolves the provider from the scan, so multi-provider universal frameworks (e.g. CSA CCM) return the check IDs of the scan's provider and Azure/GCP requirement details show their findings instead of appearing empty [(#11546)](https://github.com/prowler-cloud/prowler/pull/11546)
+- Attack Paths: `drop_subgraph` now deletes relationships first and then nodes in batches, using less memory on Neo4j when clearing a dense provider graph [(#11557)](https://github.com/prowler-cloud/prowler/pull/11557)
+- OCI scans now use API key credentials with the configured region instead of falling back to `/home/prowler/.oci/config` [(#11558)](https://github.com/prowler-cloud/prowler/pull/11558)
+
+---
+
+## [1.31.0] (Prowler v5.30.0)
 
 ### 🚀 Added
 
 - Opt-in automatic recovery of allowlisted idempotent background tasks whose worker died during a deploy or crash: when enabled via `DJANGO_TASK_RECOVERY_ENABLED` (off by default), stuck summary and deletion tasks are detected and re-run instead of staying pending forever (scan and Jira tasks are excluded), with a `reconcile_orphan_tasks` management command for on-demand recovery [(#11416)](https://github.com/prowler-cloud/prowler/pull/11416)
 - DORA compliance framework support [(#11131)](https://github.com/prowler-cloud/prowler/pull/11131)
 - Label Postgres connections with `application_name="<component>:<alias>"` (component injected per process via `DJANGO_APP_COMPONENT`) so connections are attributable by component in `pg_stat_activity` [(#11494)](https://github.com/prowler-cloud/prowler/pull/11494)
+- DISA Okta IDaaS STIG V1R2 compliance framework export support for the Okta provider [(#11428)](https://github.com/prowler-cloud/prowler/pull/11428)
 
 ### 🔄 Changed
 
@@ -17,10 +28,12 @@ All notable changes to the **Prowler API** are documented in this file.
 ### 🐞 Fixed
 
 - Workers now shut down gracefully on deploy or restart, finishing or re-queueing in-flight tasks instead of being force-killed and leaving them stuck [(#11416)](https://github.com/prowler-cloud/prowler/pull/11416)
+- Resource `name` is now stored and refreshed on every scan, so resources no longer keep an empty name [(#11476)](https://github.com/prowler-cloud/prowler/pull/11476)
+- Compliance catalog now warms in background during startup. `compliance-overviews/attributes` returns `503` while warming, so the first request after a deploy no longer trips the API timeout [(#11530)](https://github.com/prowler-cloud/prowler/pull/11530)
 
 ### 🔐 Security
 
-- `dulwich` from 0.23.0 to 1.2.5 and `pyjwt` from 2.12.1 to 2.13.0, patching `GHSA-897w-fcg9-f6xj` (arbitrary file write) and `PYSEC-2026-179` (HMAC/JWK key confusion) flagged by osv-scanner in `api/uv.lock` [(#11499)](https://github.com/prowler-cloud/prowler/pull/11499)
+- `dulwich` from 0.23.0 to 1.2.5 and `pyjwt` from 2.12.1 to 2.13.0, patching `GHSA-897w-fcg9-f6xj` (arbitrary file write) and `PYSEC-2026-179` (HMAC/JWK key confusion) [(#11499)](https://github.com/prowler-cloud/prowler/pull/11499)
 
 ---
 

api/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
   "defusedxml==0.7.1",
   "gunicorn==23.0.0",
   "lxml==6.1.0",
-  "prowler @ git+https://github.com/prowler-cloud/prowler.git@master",
+  "prowler @ git+https://github.com/prowler-cloud/prowler.git@v5.30",
   "psycopg2-binary==2.9.9",
   "pytest-celery[redis] (==1.3.0)",
   "sentry-sdk[django] (==2.56.0)",
@@ -68,7 +68,7 @@ name = "prowler-api"
 package-mode = false
 # Needed for the SDK compatibility
 requires-python = ">=3.11,<3.13"
-version = "1.31.0"
+version = "1.31.1"
 
 [tool.uv]
 # Transitive pins matching master to avoid silent drift; bump deliberately.

api/src/backend/api/attack_paths/database.py

@@ -175,7 +175,8 @@ def drop_subgraph(database: str, provider_id: str) -> int:
     """
     Delete all nodes for a provider from the tenant database.
 
-    Uses batched deletion to avoid memory issues with large graphs.
+    Deletes relationships then nodes in batches (not `DETACH DELETE`) so a dense
+    provider's graph cannot exceed Neo4j's transaction memory limit.
     Silently returns 0 if the database doesn't exist.
     """
     provider_label = get_provider_label(provider_id)
@@ -183,13 +184,28 @@ def drop_subgraph(database: str, provider_id: str) -> int:
 
     try:
         with get_session(database) as session:
+            # Phase 1: delete relationships incident to provider nodes in batches.
+            deleted_count = 1
+            while deleted_count > 0:
+                result = session.run(
+                    f"""
+                    MATCH (:`{provider_label}`)-[r]-()
+                    WITH DISTINCT r LIMIT $batch_size
+                    DELETE r
+                    RETURN COUNT(r) AS deleted_rels_count
+                    """,
+                    {"batch_size": BATCH_SIZE},
+                )
+                deleted_count = result.single().get("deleted_rels_count", 0)
+
+            # Phase 2: delete the now relationship-free nodes in batches.
             deleted_count = 1
             while deleted_count > 0:
                 result = session.run(
                     f"""
                     MATCH (n:{PROVIDER_RESOURCE_LABEL}:`{provider_label}`)
                     WITH n LIMIT $batch_size
-                    DETACH DELETE n
+                    DELETE n
                     RETURN COUNT(n) AS deleted_nodes_count
                     """,
                     {"batch_size": BATCH_SIZE},

api/src/backend/api/compliance.py

@@ -1,3 +1,5 @@
+import logging
+import threading
 from collections.abc import Iterable, Mapping
 
 from api.models import Provider
@@ -6,8 +8,19 @@ from prowler.lib.check.compliance_models import (
 )
 from prowler.lib.check.models import CheckMetadata
 
+logger = logging.getLogger(__name__)
+
 AVAILABLE_COMPLIANCE_FRAMEWORKS = {}
 
+# Per-process readiness flags for the background compliance warm-up.
+# `STARTED` is set as soon as warming begins (only happens under Gunicorn via
+# the post_fork hook); `WARMED` is set when it finishes. The attributes
+# endpoint checks both: it returns 503 only while warming is in progress.
+# Under `runserver` warming never runs, so `STARTED` stays clear and the
+# endpoint keeps lazy-loading as before.
+COMPLIANCE_WARMING_STARTED = threading.Event()
+COMPLIANCE_WARMED = threading.Event()
+
 
 class LazyComplianceTemplate(Mapping):
     """Lazy-load compliance templates per provider on first access."""
@@ -174,6 +187,56 @@ def _ensure_provider_loaded(provider_type: Provider.ProviderChoices) -> None:
         PROWLER_CHECKS._cache[provider_type] = checks
 
 
+def warm_compliance_caches(
+    provider_types: Iterable[str] | None = None,
+) -> list[str]:
+    """
+    Eagerly populate the per-process compliance caches at server startup.
+
+    Moves the cold-cache catalog load off the request thread so the first
+    request does not trip the Gunicorn worker timeout. Reads only on-disk
+    metadata (no database access). Each provider is warmed in isolation;
+    failures are logged and fall back to lazy loading.
+
+    Args:
+        provider_types (Iterable[str] | None): Subset to warm. Defaults to all.
+
+    Returns:
+        list[str]: Provider types that could not be warmed.
+    """
+    if provider_types is None:
+        provider_types = Provider.ProviderChoices.values
+    provider_types = list(provider_types)
+
+    COMPLIANCE_WARMING_STARTED.set()
+    logger.info("Compliance cache warm-up started for providers: %s", provider_types)
+
+    failed = []
+    for provider_type in provider_types:
+        try:
+            get_compliance_frameworks(provider_type)
+            _ensure_provider_loaded(provider_type)
+        # Prowler check loading may sys.exit (SystemExit, not Exception).
+        except (Exception, SystemExit):
+            logger.warning(
+                "Failed to warm compliance caches for provider '%s'; "
+                "loading lazily on first request",
+                provider_type,
+                exc_info=True,
+            )
+            failed.append(provider_type)
+
+    # Mark as warmed even when some providers failed: a failed provider falls
+    # back to a single-provider lazy load, which stays under the worker timeout.
+    COMPLIANCE_WARMED.set()
+    logger.info(
+        "Compliance cache warm-up finished (providers warmed: %d, failed: %s)",
+        len(provider_types) - len(failed),
+        failed,
+    )
+    return failed
+
+
 def load_prowler_checks(
     prowler_compliance, provider_types: Iterable[str] | None = None
 ):

api/src/backend/api/exceptions.py

@@ -187,6 +187,32 @@ class UpstreamServiceUnavailableError(APIException):
         )
 
 
+class ComplianceWarmingError(APIException):
+    """Compliance catalog is still warming (503 Service Unavailable).
+
+    Returned by the compliance attributes endpoint while the per-process
+    catalog warm-up is in progress, so the request thread never triggers the
+    slow cold load that would trip the Gunicorn worker timeout.
+    """
+
+    status_code = status.HTTP_503_SERVICE_UNAVAILABLE
+    default_detail = (
+        "Compliance data is still loading. Please try again in a few seconds."
+    )
+    default_code = "compliance_warming"
+
+    def __init__(self, detail=None):
+        super().__init__(
+            detail=[
+                {
+                    "detail": detail or self.default_detail,
+                    "status": str(self.status_code),
+                    "code": self.default_code,
+                }
+            ]
+        )
+
+
 class UpstreamInternalError(APIException):
     """Unexpected error communicating with provider (500 Internal Server Error).
 

api/src/backend/api/specs/v1.yaml

@@ -1,7 +1,7 @@
 openapi: 3.0.3
 info:
   title: Prowler API
-  version: 1.31.0
+  version: 1.31.1
   description: |-
     Prowler API specification.
 

api/src/backend/api/tests/test_attack_paths_database.py

@@ -542,3 +542,84 @@ class TestHasProviderData:
         ):
             with pytest.raises(db_module.GraphDatabaseQueryException):
                 db_module.has_provider_data("db-tenant-abc", "provider-123")
+
+
+class TestDropSubgraph:
+    """Test drop_subgraph two-phase batched deletion of a provider's graph."""
+
+    @staticmethod
+    def _result(count):
+        result = MagicMock()
+        result.single.return_value.get.return_value = count
+        return result
+
+    @staticmethod
+    def _session_ctx(session):
+        ctx = MagicMock()
+        ctx.__enter__.return_value = session
+        ctx.__exit__.return_value = False
+        return ctx
+
+    def test_deletes_relationships_then_nodes_in_batches(self):
+        session = MagicMock()
+        # Phase 1 (relationships): one full batch then empty.
+        # Phase 2 (nodes): one full batch then empty.
+        session.run.side_effect = [
+            self._result(1000),
+            self._result(0),
+            self._result(1000),
+            self._result(0),
+        ]
+
+        with patch(
+            "api.attack_paths.database.get_session",
+            return_value=self._session_ctx(session),
+        ):
+            deleted = db_module.drop_subgraph("db-tenant-abc", "provider-123")
+
+        # Only phase-2 node counts contribute to the return value.
+        assert deleted == 1000
+        assert session.run.call_count == 4
+
+        queries = [call.args[0] for call in session.run.call_args_list]
+
+        # Regression guard: the memory blow-up was caused by DETACH DELETE.
+        assert all("DETACH DELETE" not in query for query in queries)
+
+        rel_queries = [query for query in queries if "DELETE r" in query]
+        node_queries = [query for query in queries if "DELETE n" in query]
+        assert rel_queries and node_queries
+        # DISTINCT avoids double-counting relationships matched from both ends.
+        assert all("DISTINCT r" in query for query in rel_queries)
+
+        # Relationships must be fully drained before nodes are deleted.
+        first_node = next(i for i, q in enumerate(queries) if "DELETE n" in q)
+        last_rel = max(i for i, q in enumerate(queries) if "DELETE r" in q)
+        assert last_rel < first_node
+
+    def test_returns_zero_when_database_not_found(self):
+        session_ctx = MagicMock()
+        session_ctx.__enter__.side_effect = db_module.GraphDatabaseQueryException(
+            message="Database does not exist",
+            code="Neo.ClientError.Database.DatabaseNotFound",
+        )
+
+        with patch(
+            "api.attack_paths.database.get_session",
+            return_value=session_ctx,
+        ):
+            assert db_module.drop_subgraph("db-tenant-gone", "provider-123") == 0
+
+    def test_raises_on_other_errors(self):
+        session_ctx = MagicMock()
+        session_ctx.__enter__.side_effect = db_module.GraphDatabaseQueryException(
+            message="Connection refused",
+            code="Neo.TransientError.General.UnknownError",
+        )
+
+        with patch(
+            "api.attack_paths.database.get_session",
+            return_value=session_ctx,
+        ):
+            with pytest.raises(db_module.GraphDatabaseQueryException):
+                db_module.drop_subgraph("db-tenant-abc", "provider-123")

api/src/backend/api/tests/test_compliance.py

@@ -10,6 +10,7 @@ from api.compliance import (
     get_prowler_provider_checks,
     get_prowler_provider_compliance,
     load_prowler_checks,
+    warm_compliance_caches,
 )
 from api.models import Provider
 from prowler.lib.check.compliance_models import (
@@ -267,11 +268,17 @@ def reset_compliance_cache():
     """Reset the module-level cache so each test starts cold."""
     previous = dict(compliance_module.AVAILABLE_COMPLIANCE_FRAMEWORKS)
     compliance_module.AVAILABLE_COMPLIANCE_FRAMEWORKS.clear()
+    # The warming flags are module-global; clear them so they do not leak
+    # between tests that call warm_compliance_caches.
+    compliance_module.COMPLIANCE_WARMING_STARTED.clear()
+    compliance_module.COMPLIANCE_WARMED.clear()
     try:
         yield
     finally:
         compliance_module.AVAILABLE_COMPLIANCE_FRAMEWORKS.clear()
         compliance_module.AVAILABLE_COMPLIANCE_FRAMEWORKS.update(previous)
+        compliance_module.COMPLIANCE_WARMING_STARTED.clear()
+        compliance_module.COMPLIANCE_WARMED.clear()
 
 
 class TestGetComplianceFrameworks:
@@ -321,3 +328,89 @@ class TestGetComplianceFrameworks:
             f"loadable by get_bulk_compliance_frameworks_universal: "
             f"{sorted(missing)}"
         )
+
+
+class TestWarmComplianceCaches:
+    def test_warms_all_provider_types_by_default(self, reset_compliance_cache):
+        provider_types = list(Provider.ProviderChoices.values)
+        with (
+            patch("api.compliance.get_compliance_frameworks") as mock_frameworks,
+            patch("api.compliance._ensure_provider_loaded") as mock_ensure,
+        ):
+            warm_compliance_caches()
+
+        warmed = {call.args[0] for call in mock_frameworks.call_args_list}
+        assert warmed == set(provider_types)
+        assert mock_frameworks.call_count == len(provider_types)
+        assert mock_ensure.call_count == len(provider_types)
+
+    def test_warms_only_requested_provider_types(self, reset_compliance_cache):
+        with (
+            patch("api.compliance.get_compliance_frameworks") as mock_frameworks,
+            patch("api.compliance._ensure_provider_loaded") as mock_ensure,
+        ):
+            warm_compliance_caches([Provider.ProviderChoices.AWS])
+
+        mock_frameworks.assert_called_once_with(Provider.ProviderChoices.AWS)
+        mock_ensure.assert_called_once_with(Provider.ProviderChoices.AWS)
+
+    def test_populates_module_cache(self, reset_compliance_cache):
+        with (
+            patch(
+                "api.compliance.get_bulk_compliance_frameworks_universal"
+            ) as mock_get_bulk,
+            patch("api.compliance._ensure_provider_loaded"),
+        ):
+            mock_get_bulk.return_value = {"cis_1.4_aws": MagicMock()}
+            warm_compliance_caches([Provider.ProviderChoices.AWS])
+
+        assert (
+            Provider.ProviderChoices.AWS
+            in compliance_module.AVAILABLE_COMPLIANCE_FRAMEWORKS
+        )
+
+    def test_failing_provider_does_not_abort_the_rest(self, reset_compliance_cache):
+        """A failing provider (even on SystemExit) is isolated; others warm."""
+        providers = [Provider.ProviderChoices.AWS, Provider.ProviderChoices.OKTA]
+
+        def fake_frameworks(provider_type):
+            if provider_type == Provider.ProviderChoices.OKTA:
+                raise SystemExit(1)
+            return []
+
+        with (
+            patch(
+                "api.compliance.get_compliance_frameworks", side_effect=fake_frameworks
+            ),
+            patch("api.compliance._ensure_provider_loaded") as mock_ensure,
+        ):
+            failed = warm_compliance_caches(providers)
+
+        assert failed == [Provider.ProviderChoices.OKTA]
+        mock_ensure.assert_called_once_with(Provider.ProviderChoices.AWS)
+
+    def test_sets_readiness_flags(self, reset_compliance_cache):
+        assert not compliance_module.COMPLIANCE_WARMING_STARTED.is_set()
+        assert not compliance_module.COMPLIANCE_WARMED.is_set()
+
+        with (
+            patch("api.compliance.get_compliance_frameworks"),
+            patch("api.compliance._ensure_provider_loaded"),
+        ):
+            warm_compliance_caches([Provider.ProviderChoices.AWS])
+
+        assert compliance_module.COMPLIANCE_WARMING_STARTED.is_set()
+        assert compliance_module.COMPLIANCE_WARMED.is_set()
+
+    def test_marks_warmed_even_when_a_provider_fails(self, reset_compliance_cache):
+        """A failed provider still leaves the caches flagged as warmed."""
+        with (
+            patch(
+                "api.compliance.get_compliance_frameworks",
+                side_effect=SystemExit(1),
+            ),
+            patch("api.compliance._ensure_provider_loaded"),
+        ):
+            warm_compliance_caches([Provider.ProviderChoices.AWS])
+
+        assert compliance_module.COMPLIANCE_WARMED.is_set()

api/src/backend/api/tests/test_utils.py

@@ -357,6 +357,30 @@ class TestGetProwlerProviderKwargs:
         expected_result = {**secret_dict, **expected_extra_kwargs}
         assert result == expected_result
 
+    def test_get_prowler_provider_kwargs_oraclecloud_converts_region_string_to_set(
+        self,
+    ):
+        secret_dict = {
+            "user": "ocid1.user.oc1..fake",
+            "fingerprint": "00:11:22:33:44:55:66:77",
+            "key_content": "-----BEGIN PRIVATE KEY-----\nfake\n-----END PRIVATE KEY-----",
+            "tenancy": "ocid1.tenancy.oc1..fake",
+            "region": "us-ashburn-1",
+            "pass_phrase": "fake-passphrase",
+        }
+        secret_mock = MagicMock()
+        secret_mock.secret = secret_dict
+
+        provider = MagicMock()
+        provider.provider = Provider.ProviderChoices.ORACLECLOUD.value
+        provider.secret = secret_mock
+        provider.uid = "ocid1.tenancy.oc1..fake"
+
+        result = get_prowler_provider_kwargs(provider)
+
+        expected_result = {**secret_dict, "region": {"us-ashburn-1"}}
+        assert result == expected_result
+
     def test_get_prowler_provider_kwargs_with_mutelist(self):
         provider_uid = "provider_uid"
         secret_dict = {"key": "value"}

api/src/backend/api/tests/test_views.py

@@ -9570,6 +9570,188 @@ class TestComplianceOverviewViewSet:
             assert "Category" in first_attr
             assert "AWSService" in first_attr
 
+    def test_compliance_overview_attributes_resolves_provider_from_scan(
+        self, authenticated_client, tenants_fixture, providers_fixture
+    ):
+        # csa_ccm_4.0 is a multi-provider universal framework: a single
+        # compliance_id whose requirements expose different checks per provider.
+        # Passing a scan must return the check IDs for that scan's provider,
+        # otherwise the endpoint defaults to the first provider that declares the
+        # framework and azure/gcp requirements end up with check IDs that match
+        # no findings.
+        tenant = tenants_fixture[0]
+        gcp_provider = providers_fixture[2]
+        azure_provider = providers_fixture[4]
+        assert gcp_provider.provider == Provider.ProviderChoices.GCP.value
+        assert azure_provider.provider == Provider.ProviderChoices.AZURE.value
+
+        now = datetime.now(timezone.utc)
+        gcp_scan = Scan.objects.create(
+            name="gcp scan",
+            provider=gcp_provider,
+            trigger=Scan.TriggerChoices.MANUAL,
+            state=StateChoices.COMPLETED,
+            tenant_id=tenant.id,
+            started_at=now,
+            completed_at=now,
+        )
+        azure_scan = Scan.objects.create(
+            name="azure scan",
+            provider=azure_provider,
+            trigger=Scan.TriggerChoices.MANUAL,
+            state=StateChoices.COMPLETED,
+            tenant_id=tenant.id,
+            started_at=now,
+            completed_at=now,
+        )
+
+        def request_attributes(scan_id=None):
+            params = {"filter[compliance_id]": "csa_ccm_4.0"}
+            if scan_id is not None:
+                params["filter[scan_id]"] = str(scan_id)
+            return authenticated_client.get(
+                reverse("complianceoverview-attributes"), params
+            )
+
+        def collect_check_ids(scan_id=None):
+            response = request_attributes(scan_id)
+            assert response.status_code == status.HTTP_200_OK
+            check_ids = set()
+            for item in response.json()["data"]:
+                check_ids.update(item["attributes"]["attributes"]["check_ids"])
+            return check_ids
+
+        gcp_check_ids = collect_check_ids(gcp_scan.id)
+        azure_check_ids = collect_check_ids(azure_scan.id)
+
+        # Each scan resolves to its own provider's checks, and they differ.
+        assert gcp_check_ids
+        assert azure_check_ids
+        assert gcp_check_ids != azure_check_ids
+
+        # The returned check IDs belong to the SDK's per-provider definition.
+        from api.compliance import get_prowler_provider_compliance
+
+        def expected_check_ids(provider_type):
+            framework = get_prowler_provider_compliance(provider_type)["csa_ccm_4.0"]
+            expected = set()
+            for requirement in framework.requirements:
+                expected.update(requirement.checks.get(provider_type, []))
+            return expected
+
+        assert gcp_check_ids <= expected_check_ids(Provider.ProviderChoices.GCP.value)
+        assert azure_check_ids <= expected_check_ids(
+            Provider.ProviderChoices.AZURE.value
+        )
+
+        # An explicit scan_id is authoritative: a non-existent scan must fail
+        # closed with 404 instead of silently falling back to another provider.
+        missing_response = request_attributes("00000000-0000-0000-0000-000000000000")
+        assert missing_response.status_code == status.HTTP_404_NOT_FOUND
+
+        # A malformed scan_id is rejected with 404 as well.
+        malformed_response = request_attributes("not-a-uuid")
+        assert malformed_response.status_code == status.HTTP_404_NOT_FOUND
+
+        # An empty value (filter[scan_id]=) must not fall back to the legacy
+        # provider picker: the explicit (if blank) selector fails closed.
+        empty_response = request_attributes("")
+        assert empty_response.status_code == status.HTTP_404_NOT_FOUND
+
+        # A scan belonging to another tenant is not visible (RLS), so it must
+        # return 404 rather than leaking the fallback provider's check IDs.
+        other_tenant = Tenant.objects.create(name="Other Compliance Tenant")
+        foreign_provider = Provider.objects.create(
+            provider="gcp",
+            uid="foreign-gcp-test",
+            alias="foreign_gcp",
+            tenant_id=other_tenant.id,
+        )
+        foreign_scan = Scan.objects.create(
+            name="foreign scan",
+            provider=foreign_provider,
+            trigger=Scan.TriggerChoices.MANUAL,
+            state=StateChoices.COMPLETED,
+            tenant_id=other_tenant.id,
+            started_at=now,
+            completed_at=now,
+        )
+        foreign_response = request_attributes(foreign_scan.id)
+        assert foreign_response.status_code == status.HTTP_404_NOT_FOUND
+
+    def test_compliance_overview_attributes_scan_scoped_by_provider_group(
+        self,
+        authenticated_client_no_permissions_rbac,
+        providers_fixture,
+    ):
+        # A user with limited visibility (no UNLIMITED_VISIBILITY) must only be
+        # able to resolve scans for providers in its provider groups. Tenant RLS
+        # alone is not enough here: both scans belong to the same tenant, so the
+        # endpoint has to scope the scan lookup by provider group, otherwise a
+        # restricted user could read another provider's compliance metadata.
+        client = authenticated_client_no_permissions_rbac
+        limited_user = client.user
+        membership = Membership.objects.filter(user=limited_user).first()
+        tenant = membership.tenant
+
+        allowed_provider = providers_fixture[2]
+        denied_provider = providers_fixture[4]
+        assert allowed_provider.provider == Provider.ProviderChoices.GCP.value
+        assert denied_provider.provider == Provider.ProviderChoices.AZURE.value
+
+        provider_group = ProviderGroup.objects.create(
+            name="limited-compliance-group",
+            tenant_id=tenant.id,
+        )
+        ProviderGroupMembership.objects.create(
+            tenant_id=tenant.id,
+            provider_group=provider_group,
+            provider=allowed_provider,
+        )
+        RoleProviderGroupRelationship.objects.create(
+            tenant_id=tenant.id,
+            role=limited_user.roles.first(),
+            provider_group=provider_group,
+        )
+
+        now = datetime.now(timezone.utc)
+        allowed_scan = Scan.objects.create(
+            name="allowed scan",
+            provider=allowed_provider,
+            trigger=Scan.TriggerChoices.MANUAL,
+            state=StateChoices.COMPLETED,
+            tenant_id=tenant.id,
+            started_at=now,
+            completed_at=now,
+        )
+        denied_scan = Scan.objects.create(
+            name="denied scan",
+            provider=denied_provider,
+            trigger=Scan.TriggerChoices.MANUAL,
+            state=StateChoices.COMPLETED,
+            tenant_id=tenant.id,
+            started_at=now,
+            completed_at=now,
+        )
+
+        def request_attributes(scan_id):
+            return client.get(
+                reverse("complianceoverview-attributes"),
+                {
+                    "filter[compliance_id]": "csa_ccm_4.0",
+                    "filter[scan_id]": str(scan_id),
+                },
+            )
+
+        # The scan in the user's provider group resolves normally.
+        assert request_attributes(allowed_scan.id).status_code == status.HTTP_200_OK
+
+        # The scan outside the user's provider group is invisible, so it fails
+        # closed with 404 instead of leaking the other provider's check IDs.
+        assert (
+            request_attributes(denied_scan.id).status_code == status.HTTP_404_NOT_FOUND
+        )
+
     def test_compliance_overview_attributes_missing_compliance_id(
         self, authenticated_client
     ):
@@ -9578,6 +9760,39 @@ class TestComplianceOverviewViewSet:
         )
         assert response.status_code == status.HTTP_400_BAD_REQUEST
 
+    def test_compliance_overview_attributes_503_while_warming(
+        self, authenticated_client
+    ):
+        from api.compliance import COMPLIANCE_WARMED, COMPLIANCE_WARMING_STARTED
+
+        COMPLIANCE_WARMING_STARTED.set()
+        COMPLIANCE_WARMED.clear()
+        try:
+            response = authenticated_client.get(
+                reverse("complianceoverview-attributes"),
+                {"filter[compliance_id]": "aws_account_security_onboarding_aws"},
+            )
+        finally:
+            COMPLIANCE_WARMING_STARTED.clear()
+
+        assert response.status_code == status.HTTP_503_SERVICE_UNAVAILABLE
+        assert response.json()["errors"][0]["code"] == "compliance_warming"
+
+    def test_compliance_overview_attributes_serves_when_warming_not_started(
+        self, authenticated_client
+    ):
+        # Dev fallback: under runserver warming never runs, so the guard must
+        # not refuse — the endpoint lazily loads and serves as before.
+        from api.compliance import COMPLIANCE_WARMED, COMPLIANCE_WARMING_STARTED
+
+        COMPLIANCE_WARMING_STARTED.clear()
+        COMPLIANCE_WARMED.clear()
+        response = authenticated_client.get(
+            reverse("complianceoverview-attributes"),
+            {"filter[compliance_id]": "aws_account_security_onboarding_aws"},
+        )
+        assert response.status_code == status.HTTP_200_OK
+
     def test_compliance_overview_task_management_integration(
         self, authenticated_client, compliance_requirements_overviews_fixture
     ):

api/src/backend/api/utils.py

@@ -243,6 +243,12 @@ def get_prowler_provider_kwargs(
             **prowler_provider_kwargs,
             "filter_accounts": [provider.uid],
         }
+    elif provider.provider == Provider.ProviderChoices.ORACLECLOUD.value:
+        if isinstance(prowler_provider_kwargs.get("region"), str):
+            prowler_provider_kwargs = {
+                **prowler_provider_kwargs,
+                "region": {prowler_provider_kwargs["region"]},
+            }
     elif provider.provider == Provider.ProviderChoices.OPENSTACK.value:
         # clouds_yaml_content, clouds_yaml_cloud and provider_id are validated
         # in the provider itself, so it's not needed here.

api/src/backend/api/v1/views.py

@@ -30,6 +30,7 @@ from dj_rest_auth.registration.views import SocialLoginView
 from django.conf import settings as django_settings
 from django.contrib.postgres.aggregates import ArrayAgg, BoolAnd, StringAgg
 from django.contrib.postgres.search import SearchQuery
+from django.core.exceptions import ValidationError as DjangoValidationError
 from django.db import transaction
 from django.db.models import (
     BooleanField,
@@ -114,6 +115,8 @@ from api.attack_paths import get_queries_for_provider, get_query_by_id
 from api.attack_paths import views_helpers as attack_paths_views_helpers
 from api.base_views import BaseRLSViewSet, BaseTenantViewset, BaseUserViewset
 from api.compliance import (
+    COMPLIANCE_WARMED,
+    COMPLIANCE_WARMING_STARTED,
     PROWLER_COMPLIANCE_OVERVIEW_TEMPLATE,
     get_compliance_frameworks,
     get_prowler_provider_compliance,
@@ -122,6 +125,7 @@ from api.constants import SEVERITY_ORDER
 from api.db_router import MainRouter
 from api.db_utils import rls_transaction
 from api.exceptions import (
+    ComplianceWarmingError,
     TaskFailedException,
     UpstreamAccessDeniedError,
     UpstreamAuthenticationError,
@@ -4641,6 +4645,16 @@ class RoleProviderGroupRelationshipView(RelationshipView, BaseRLSViewSet):
                 location=OpenApiParameter.QUERY,
                 description="Compliance framework ID to get attributes for.",
             ),
+            OpenApiParameter(
+                name="filter[scan_id]",
+                required=False,
+                type=OpenApiTypes.UUID,
+                location=OpenApiParameter.QUERY,
+                description="Scan ID used to resolve the provider for "
+                "multi-provider universal frameworks (e.g. CSA CCM), so "
+                "the returned check IDs match the scan's provider. When omitted, "
+                "the first provider that declares the framework is used.",
+            ),
         ],
         responses={
             200: OpenApiResponse(
@@ -5059,6 +5073,13 @@ class ComplianceOverviewViewSet(BaseRLSViewSet, TaskManagementMixin):
 
     @action(detail=False, methods=["get"], url_name="attributes")
     def attributes(self, request):
+        # While the background warm-up is in progress, refuse immediately
+        # instead of falling through to the slow cold load on the request
+        # thread (which would trip the Gunicorn worker timeout). `is_set()` is
+        # a non-blocking flag read, so this never touches the loader.
+        if COMPLIANCE_WARMING_STARTED.is_set() and not COMPLIANCE_WARMED.is_set():
+            raise ComplianceWarmingError()
+
         compliance_id = request.query_params.get("filter[compliance_id]")
         if not compliance_id:
             raise ValidationError(
@@ -5074,7 +5095,51 @@ class ComplianceOverviewViewSet(BaseRLSViewSet, TaskManagementMixin):
 
         provider_type = None
 
-        # If we couldn't determine from database, try each provider type
+        # When a scan is provided, resolve the provider from it. Multi-provider
+        # universal frameworks (e.g. CSA CCM) share a single compliance_id
+        # across providers but expose different checks per provider, so the
+        # metadata (and therefore the check IDs the UI uses to fetch findings)
+        # must be returned for the scan's provider. Without this, the endpoint
+        # falls back to the first provider that declares the framework and
+        # returns its check IDs, leaving azure/gcp/... requirements with no
+        # matching findings.
+        scan_id = request.query_params.get("filter[scan_id]")
+        if "filter[scan_id]" in request.query_params:
+            # An explicit scan_id is authoritative: fail closed instead of
+            # falling back to another provider. Otherwise an invalid, empty
+            # (filter[scan_id]=) or inaccessible scan would silently return the
+            # first provider's check IDs, recreating the multi-provider mismatch
+            # this endpoint fixes.
+            if not scan_id:
+                raise NotFound(detail=f"Scan '{scan_id}' not found.")
+
+            # Tenant isolation is already enforced by Postgres RLS on the
+            # connection (see BaseRLSViewSet). Scope the lookup by provider
+            # group as well so a user with limited visibility can't resolve
+            # another provider's scan and read its compliance metadata, mirroring
+            # the RBAC scoping get_queryset() applies to the rest of the ViewSet.
+            role = get_role(request.user, request.tenant_id)
+            if getattr(role, Permissions.UNLIMITED_VISIBILITY.value, False):
+                scan_queryset = Scan.objects.filter(tenant_id=request.tenant_id)
+            else:
+                scan_queryset = Scan.objects.filter(provider__in=get_providers(role))
+
+            try:
+                scan = scan_queryset.select_related("provider").get(id=scan_id)
+            except (Scan.DoesNotExist, DjangoValidationError, ValueError):
+                raise NotFound(detail=f"Scan '{scan_id}' not found.")
+
+            provider_type = scan.provider.provider
+            if compliance_id not in get_compliance_frameworks(provider_type):
+                raise NotFound(
+                    detail=(
+                        f"Compliance framework '{compliance_id}' is not "
+                        f"available for scan '{scan_id}'."
+                    )
+                )
+
+        # Fall back to the first provider that declares the framework. Keeps the
+        # endpoint working for provider-agnostic callers that omit the scan.
         if not provider_type:
             for pt in Provider.ProviderChoices.values:
                 if compliance_id in get_compliance_frameworks(pt):

api/src/backend/config/guniconf.py

@@ -1,6 +1,7 @@
 import logging
 import multiprocessing
 import os
+import threading
 
 from config.env import env
 
@@ -11,6 +12,7 @@ os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.django.production")
 import django  # noqa: E402
 
 django.setup()
+from api.compliance import warm_compliance_caches  # noqa: E402
 from config.django.production import LOGGING as DJANGO_LOGGERS, DEBUG  # noqa: E402
 from config.custom_logging import BackendLogger  # noqa: E402
 
@@ -41,3 +43,26 @@ def on_reload(_):
 
 def when_ready(_):
     gunicorn_logger.info("Gunicorn server is ready")
+
+
+def _warm_compliance_caches_in_background():
+    """Warm compliance caches off the request path and log the outcome."""
+    failed = warm_compliance_caches()
+    if failed:
+        gunicorn_logger.warning("Compliance caches warmed (skipped: %s)", failed)
+    else:
+        gunicorn_logger.info("Compliance caches warmed")
+
+
+def post_fork(_server, worker):
+    """Warm compliance caches after each worker fork.
+
+    Warm compliance caches in a background thread so the worker becomes ready
+    immediately. A request for a not-yet-warmed provider lazily loads just that
+    provider, which stays well under the worker timeout.
+    """
+    threading.Thread(
+        target=_warm_compliance_caches_in_background,
+        name="warm-compliance-caches",
+        daemon=True,
+    ).start()

api/src/backend/tasks/jobs/export.py

@@ -58,6 +58,9 @@ from prowler.lib.outputs.compliance.mitre_attack.mitre_attack_azure import (
     AzureMitreAttack,
 )
 from prowler.lib.outputs.compliance.mitre_attack.mitre_attack_gcp import GCPMitreAttack
+from prowler.lib.outputs.compliance.okta_idaas_stig.okta_idaas_stig_okta import (
+    OktaIDaaSSTIG,
+)
 from prowler.lib.outputs.compliance.prowler_threatscore.prowler_threatscore_alibaba import (
     ProwlerThreatScoreAlibaba,
 )
@@ -152,6 +155,9 @@ COMPLIANCE_CLASS_MAP = {
             ProwlerThreatScoreAlibaba,
         ),
     ],
+    "okta": [
+        (lambda name: name.startswith("okta_idaas_stig"), OktaIDaaSSTIG),
+    ],
 }
 
 

api/src/backend/tasks/jobs/scan.py

@@ -269,6 +269,7 @@ def _store_resources(
             provider=provider_instance,
             uid=finding.resource_uid,
             defaults={
+                "name": finding.resource_name,
                 "region": finding.region,
                 "service": finding.service_name,
                 "type": finding.resource_type,
@@ -276,6 +277,7 @@ def _store_resources(
         )
 
         if not created:
+            resource_instance.name = finding.resource_name
             resource_instance.region = finding.region
             resource_instance.service = finding.service_name
             resource_instance.type = finding.resource_type
@@ -704,6 +706,12 @@ def _process_finding_micro_batch(
                     if finding.region and resource_instance.region != finding.region:
                         resource_instance.region = finding.region
                         updated = True
+                    if (
+                        finding.resource_name
+                        and resource_instance.name != finding.resource_name
+                    ):
+                        resource_instance.name = finding.resource_name
+                        updated = True
                     if resource_instance.service != finding.service_name:
                         resource_instance.service = finding.service_name
                         updated = True
@@ -945,6 +953,7 @@ def _process_finding_micro_batch(
                         Resource.objects.bulk_update(
                             resources_to_bulk_update,
                             [
+                                "name",
                                 "metadata",
                                 "details",
                                 "partition",

api/src/backend/tasks/tests/test_scan.py

@@ -315,6 +315,7 @@ class TestPerformScan:
             provider=provider_instance,
             uid=finding.resource_uid,
             defaults={
+                "name": finding.resource_name,
                 "region": finding.region,
                 "service": finding.service_name,
                 "type": finding.resource_type,
@@ -348,6 +349,7 @@ class TestPerformScan:
 
         resource_instance = MagicMock()
         resource_instance.uid = finding.resource_uid
+        resource_instance.name = "old_name"
         resource_instance.region = "us-west-1"
         resource_instance.service = "old_service"
         resource_instance.type = "old_type"
@@ -366,6 +368,7 @@ class TestPerformScan:
             provider=provider_instance,
             uid=finding.resource_uid,
             defaults={
+                "name": finding.resource_name,
                 "region": finding.region,
                 "service": finding.service_name,
                 "type": finding.resource_type,
@@ -373,6 +376,7 @@ class TestPerformScan:
         )
 
         # Check that resource fields were updated
+        assert resource_instance.name == finding.resource_name
         assert resource_instance.region == finding.region
         assert resource_instance.service == finding.service_name
         assert resource_instance.type == finding.resource_type
@@ -1565,6 +1569,75 @@ class TestProcessFindingMicroBatch:
         assert resource_cache[finding.resource_uid].service == finding.service_name
         assert tag_cache.keys() == {("team", "devsec")}
 
+    def test_process_finding_micro_batch_refreshes_empty_resource_name(
+        self, tenants_fixture, scans_fixture
+    ):
+        tenant = tenants_fixture[0]
+        scan = scans_fixture[0]
+        provider = scan.provider
+
+        # Old resource stored before names were persisted: empty name.
+        existing_resource = Resource.objects.create(
+            tenant_id=tenant.id,
+            provider=provider,
+            uid="arn:aws:s3:::my-bucket",
+            name="",
+            region="us-east-1",
+            service="s3",
+            type="bucket",
+        )
+
+        finding = FakeFinding(
+            uid="finding-empty-name",
+            status=StatusChoices.PASS,
+            status_extended="passing",
+            severity=Severity.low,
+            check_id="s3_bucket_public_access",
+            resource_uid=existing_resource.uid,
+            resource_name="my-bucket",
+            region="us-east-1",
+            service_name="s3",
+            resource_type="bucket",
+            partition="aws",
+            raw={"status": "PASS"},
+            metadata={"source": "prowler"},
+        )
+
+        resource_cache = {existing_resource.uid: existing_resource}
+        tag_cache = {}
+        last_status_cache = {}
+        resource_failed_findings_cache = {existing_resource.uid: 0}
+        unique_resources: set[tuple[str, str]] = set()
+        scan_resource_cache: set[tuple[str, str, str, str]] = set()
+        mute_rules_cache = {}
+        scan_categories_cache: dict[tuple[str, str], dict[str, int]] = {}
+        scan_resource_groups_cache: dict[tuple[str, str], dict[str, int]] = {}
+        group_resources_cache: dict[str, set] = {}
+
+        with (
+            patch("tasks.jobs.scan.rls_transaction", new=noop_rls_transaction),
+            patch("api.db_utils.rls_transaction", new=noop_rls_transaction),
+        ):
+            _process_finding_micro_batch(
+                str(tenant.id),
+                [finding],
+                scan,
+                provider,
+                resource_cache,
+                tag_cache,
+                last_status_cache,
+                resource_failed_findings_cache,
+                unique_resources,
+                scan_resource_cache,
+                mute_rules_cache,
+                scan_categories_cache,
+                scan_resource_groups_cache,
+                group_resources_cache,
+            )
+
+        existing_resource.refresh_from_db()
+        assert existing_resource.name == finding.resource_name
+
     def test_process_finding_micro_batch_skips_long_uid(
         self, tenants_fixture, scans_fixture
     ):

api/uv.lock

@@ -4415,8 +4415,8 @@ wheels = [
 
 [[package]]
 name = "prowler"
-version = "5.27.0"
-source = { git = "https://github.com/prowler-cloud/prowler.git?rev=master#0abbb7fc590eaf7de6ed354dd5a217bca261d2b0" }
+version = "5.30.0"
+source = { git = "https://github.com/prowler-cloud/prowler.git?rev=v5.30#f1d741214a60df17158c3fdc97804fd1fde64f3a" }
 dependencies = [
     { name = "alibabacloud-actiontrail20200706" },
     { name = "alibabacloud-credentials" },
@@ -4489,9 +4489,14 @@ dependencies = [
     { name = "pygithub" },
     { name = "python-dateutil" },
     { name = "pytz" },
+    { name = "scaleway" },
     { name = "schema" },
     { name = "shodan" },
     { name = "slack-sdk" },
+    { name = "stackit-core" },
+    { name = "stackit-iaas" },
+    { name = "stackit-objectstorage" },
+    { name = "stackit-resourcemanager" },
     { name = "tabulate" },
     { name = "tzlocal" },
     { name = "uuid6" },
@@ -4499,7 +4504,7 @@ dependencies = [
 
 [[package]]
 name = "prowler-api"
-version = "1.31.0"
+version = "1.31.1"
 source = { virtual = "." }
 dependencies = [
     { name = "cartography" },
@@ -4595,7 +4600,7 @@ requires-dist = [
     { name = "matplotlib", specifier = "==3.10.8" },
     { name = "neo4j", specifier = "==6.1.0" },
     { name = "openai", specifier = "==1.109.1" },
-    { name = "prowler", git = "https://github.com/prowler-cloud/prowler.git?rev=master" },
+    { name = "prowler", git = "https://github.com/prowler-cloud/prowler.git?rev=v5.30" },
     { name = "psycopg2-binary", specifier = "==2.9.9" },
     { name = "pytest-celery", extras = ["redis"], specifier = "==1.3.0" },
     { name = "reportlab", specifier = "==4.4.10" },
@@ -5531,6 +5536,67 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/49/4b/359f28a903c13438ef59ebeee215fb25da53066db67b305c125f1c6d2a25/sqlparse-0.5.5-py3-none-any.whl", hash = "sha256:12a08b3bf3eec877c519589833aed092e2444e68240a3577e8e26148acc7b1ba", size = 46138, upload-time = "2025-12-19T07:17:46.573Z" },
 ]
 
+[[package]]
+name = "stackit-core"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cryptography" },
+    { name = "pydantic" },
+    { name = "pyjwt", extra = ["crypto"] },
+    { name = "requests" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/24/90/20f9ec7387eec4067cfd3d29055d0e2b5e1e0322c601a7f48125fd8ea35f/stackit_core-0.2.0.tar.gz", hash = "sha256:b8af91877cdb060d6969a303d8cf20bc0b33b345afd91f679c44a987381e2d47", size = 8987, upload-time = "2025-06-12T08:24:45.251Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/b4/7b53187ce68956870d864ccb9ccfb68066c9df9de1c9568fd2feb03c4504/stackit_core-0.2.0-py3-none-any.whl", hash = "sha256:04632fc6742790d08ddfcb7f2313e04d1254827397a80250f838a2f81b92645b", size = 10240, upload-time = "2025-06-12T08:24:44.214Z" },
+]
+
+[[package]]
+name = "stackit-iaas"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dateutil" },
+    { name = "requests" },
+    { name = "stackit-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/07/24e65278300d5c3cb19cb1660bff924c80812cf8aad3e715f826bae5aa80/stackit_iaas-1.4.0.tar.gz", hash = "sha256:93523b23442350c7ebefd9129485c4c2a539f694a9c36a0f8edfaba9862057ea", size = 116236, upload-time = "2026-05-13T09:43:15.996Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/51/2201164d7bfacf47539888c735f10f6320c188252384957aa1b23121a210/stackit_iaas-1.4.0-py3-none-any.whl", hash = "sha256:3f4a32321b57ac238f73e5d660c6428186b92cc0425c1f0783ba801e377149d9", size = 316588, upload-time = "2026-05-13T09:43:14.943Z" },
+]
+
+[[package]]
+name = "stackit-objectstorage"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dateutil" },
+    { name = "requests" },
+    { name = "stackit-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/80/b790756af40a5c6d979dd688b2557394ac54b594eb4c08edc33157ba890f/stackit_objectstorage-1.4.0.tar.gz", hash = "sha256:4a3812b4de102b199f061706a802909f9e53ae9b0858769d5bd720f814c8bdbe", size = 31814, upload-time = "2026-05-13T09:43:05.027Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/f1/ffa8d5e2ec9f818c72a6f045691364eb4e927ee86641993a70882d00205a/stackit_objectstorage-1.4.0-py3-none-any.whl", hash = "sha256:1a3285c6840d95cff591d84fd21803575cb0d010c398e6575ed92987b9c39866", size = 65061, upload-time = "2026-05-13T09:43:04.13Z" },
+]
+
+[[package]]
+name = "stackit-resourcemanager"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dateutil" },
+    { name = "requests" },
+    { name = "stackit-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/2d/f458f18e48ed2b1c83df52cff7dbdfd5dd904fb2980ffd9385876e47bbd9/stackit_resourcemanager-0.8.0.tar.gz", hash = "sha256:f44542beab4130857f5a7f465cf02defeef657bdf63c1beeb3102f0ba3c003fe", size = 33943, upload-time = "2026-05-13T09:43:08.667Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/9c/38a74d0f7a89b4320f6d2366fb660638bda8860daa08748b12c713d84381/stackit_resourcemanager-0.8.0-py3-none-any.whl", hash = "sha256:dd04bb8353d041a137c4dcba190beabded7acfaff1bc98b218fce20a99389ebc", size = 81288, upload-time = "2026-05-13T09:43:07.81Z" },
+]
+
 [[package]]
 name = "statsd"
 version = "4.0.1"

dashboard/common_methods.py

@@ -1538,6 +1538,186 @@ def get_section_container_iso(data, section_1, section_2):
     return html.Div(section_containers, className="compliance-data-layout")
 
 
+def _status_bar(success, failed, classname):
+    """Build the stacked PASS/FAIL bar shown next to an accordion title."""
+    fig = go.Figure(
+        data=[
+            go.Bar(
+                name="Failed",
+                x=[failed],
+                y=[""],
+                orientation="h",
+                marker=dict(color="#e77676"),
+                width=[0.8],
+            ),
+            go.Bar(
+                name="Success",
+                x=[success],
+                y=[""],
+                orientation="h",
+                marker=dict(color="#45cc6e"),
+                width=[0.8],
+            ),
+        ]
+    )
+    fig.update_layout(
+        barmode="stack",
+        margin=dict(l=10, r=10, t=10, b=10),
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+        showlegend=False,
+        width=350,
+        height=30,
+        xaxis=dict(showticklabels=False, showgrid=False, zeroline=False),
+        yaxis=dict(showticklabels=False, showgrid=False, zeroline=False),
+        annotations=[
+            dict(
+                x=success + failed,
+                y=0,
+                xref="x",
+                yref="y",
+                text=str(success),
+                showarrow=False,
+                font=dict(color="#45cc6e", size=14),
+                xanchor="left",
+                yanchor="middle",
+            ),
+            dict(
+                x=0,
+                y=0,
+                xref="x",
+                yref="y",
+                text=str(failed),
+                showarrow=False,
+                font=dict(color="#e77676", size=14),
+                xanchor="right",
+                yanchor="middle",
+            ),
+        ],
+    )
+    fig.add_annotation(
+        x=failed,
+        y=0.3,
+        text="|",
+        showarrow=False,
+        xanchor="center",
+        yanchor="middle",
+        font=dict(size=20),
+    )
+    return dcc.Graph(figure=fig, config={"staticPlot": True}, className=classname)
+
+
+def get_section_containers_generic(data, section_col, id_col):
+    """Two-level view: section -> requirement id (+ description) -> checks.
+
+    Sorts lexicographically so arbitrary requirement IDs never crash the
+    version-aware sort used by the CIS renderer.
+    """
+    data["STATUS"] = data["STATUS"].apply(map_status_to_icon)
+    data[section_col] = data[section_col].astype(str)
+    data[id_col] = data[id_col].astype(str)
+    data.sort_values(by=[section_col, id_col], inplace=True)
+
+    counts_section = data.groupby([section_col, "STATUS"]).size().unstack(fill_value=0)
+    counts_id = (
+        data.groupby([section_col, id_col, "STATUS"]).size().unstack(fill_value=0)
+    )
+
+    def count(counts, key, emoji):
+        return counts.loc[key, emoji] if emoji in counts.columns else 0
+
+    has_description = "REQUIREMENTS_DESCRIPTION" in data.columns
+    table_cols = ["CHECKID", "STATUS", "REGION", "ACCOUNTID", "RESOURCEID"]
+
+    section_containers = []
+    for section in data[section_col].unique():
+        graph_div = html.Div(
+            _status_bar(
+                count(counts_section, section, pass_emoji),
+                count(counts_section, section, fail_emoji),
+                "info-bar",
+            ),
+            className="graph-section",
+        )
+
+        internal_items = []
+        for req_id in data[data[section_col] == section][id_col].unique():
+            specific_data = data[
+                (data[section_col] == section) & (data[id_col] == req_id)
+            ]
+            data_table = dash_table.DataTable(
+                data=specific_data.to_dict("records"),
+                columns=[
+                    {"name": i, "id": i}
+                    for i in table_cols
+                    if i in specific_data.columns
+                ],
+                style_table={"overflowX": "auto"},
+                style_as_list_view=True,
+                style_cell={"textAlign": "left", "padding": "5px"},
+            )
+            graph_div_req = html.Div(
+                _status_bar(
+                    count(counts_id, (section, req_id), pass_emoji),
+                    count(counts_id, (section, req_id), fail_emoji),
+                    "info-bar-child",
+                ),
+                className="graph-section-req",
+            )
+
+            title = req_id
+            if has_description:
+                title = (
+                    f"{req_id} - {specific_data['REQUIREMENTS_DESCRIPTION'].iloc[0]}"
+                )
+            if len(title) > 130:
+                title = title[:130] + " ..."
+
+            internal_items.append(
+                html.Div(
+                    [
+                        graph_div_req,
+                        dbc.Accordion(
+                            [
+                                dbc.AccordionItem(
+                                    title=title,
+                                    children=[
+                                        html.Div(
+                                            [data_table],
+                                            className="inner-accordion-content",
+                                        )
+                                    ],
+                                )
+                            ],
+                            start_collapsed=True,
+                            flush=True,
+                        ),
+                    ],
+                    className="accordion-inner--child",
+                )
+            )
+
+        section_containers.append(
+            html.Div(
+                [
+                    graph_div,
+                    dbc.Accordion(
+                        [
+                            dbc.AccordionItem(
+                                title=f"{section}", children=internal_items
+                            )
+                        ],
+                        start_collapsed=True,
+                        flush=True,
+                    ),
+                ],
+                className="accordion-inner",
+            )
+        )
+
+    return html.Div(section_containers, className="compliance-data-layout")
+
+
 def get_section_containers_format4(data, section_1):
 
     data["STATUS"] = data["STATUS"].apply(map_status_to_icon)

dashboard/compliance/generic.py

@@ -0,0 +1,44 @@
+import warnings
+
+from dashboard.common_methods import (
+    get_section_containers_format4,
+    get_section_containers_generic,
+)
+
+warnings.filterwarnings("ignore")
+
+
+def get_table(data):
+    # Discover REQUIREMENTS_ATTRIBUTES_* columns at runtime.
+    attr_cols = [c for c in data.columns if c.startswith("REQUIREMENTS_ATTRIBUTES_")]
+
+    # Section column (in priority order):
+    #   1. REQUIREMENTS_ATTRIBUTES_SECTION — most common convention
+    #   2. First discovered attribute column — covers novel schemas
+    #   3. None — no section, group flat by requirement id
+    if "REQUIREMENTS_ATTRIBUTES_SECTION" in attr_cols:
+        section_col = "REQUIREMENTS_ATTRIBUTES_SECTION"
+    elif attr_cols:
+        section_col = attr_cols[0]
+    else:
+        section_col = None
+
+    base_cols = [
+        "REQUIREMENTS_ID",
+        "REQUIREMENTS_DESCRIPTION",
+        "STATUS",
+        "CHECKID",
+        "REGION",
+        "ACCOUNTID",
+        "RESOURCEID",
+    ]
+
+    # Two levels (section -> requirement id) when a section distinct from the
+    # id exists; otherwise group flat by requirement id.
+    if section_col and section_col != "REQUIREMENTS_ID":
+        needed = [section_col] + base_cols
+        aux = data[[c for c in needed if c in data.columns]].copy()
+        return get_section_containers_generic(aux, section_col, "REQUIREMENTS_ID")
+
+    aux = data[[c for c in base_cols if c in data.columns]].copy()
+    return get_section_containers_format4(aux, "REQUIREMENTS_ID")

dashboard/lib/layouts.py

@@ -156,7 +156,7 @@ def create_layout_compliance(
                             html.Img(src="assets/favicon.ico", className="w-5 mr-3"),
                             html.Span("Subscribe to Prowler Cloud"),
                         ],
-                        href="https://prowler.pro/",
+                        href="https://cloud.prowler.com/",
                         target="_blank",
                         className="text-prowler-stone-900 inline-flex px-4 py-2 text-xs font-bold uppercase transition-all rounded-lg text-gray-900 hover:bg-prowler-stone-900/10 border-solid border-1 hover:border-prowler-stone-900/10 hover:border-solid hover:border-1 border-prowler-stone-900/10",
                     ),

dashboard/pages/compliance.py

@@ -215,6 +215,58 @@ else:
     )
 
 
+def _ensure_scope_columns(data):
+    """Guarantee ACCOUNTID and REGION exist.
+
+    Scope columns always sit between DESCRIPTION and ASSESSMENTDATE, so derive
+    them positionally for any provider (e.g. Okta's ORGANIZATIONDOMAIN) and
+    fall back to "-" to avoid a KeyError.
+    """
+    cols = list(data.columns)
+    scope = []
+    if "DESCRIPTION" in cols and "ASSESSMENTDATE" in cols:
+        start, end = cols.index("DESCRIPTION") + 1, cols.index("ASSESSMENTDATE")
+        scope = [c for c in cols[start:end] if c not in ("ACCOUNTID", "REGION")]
+
+    if "ACCOUNTID" not in data.columns:
+        if scope:
+            data.rename(columns={scope.pop(0): "ACCOUNTID"}, inplace=True)
+        else:
+            data["ACCOUNTID"] = "-"
+    if "REGION" not in data.columns:
+        if scope:
+            data.rename(columns={scope.pop(0): "REGION"}, inplace=True)
+        else:
+            data["REGION"] = "-"
+    return data
+
+
+def _dispatch_compliance_renderer(data, analytics_input):
+    """Resolve the compliance renderer module and return (table, deduped_data).
+
+    Tries to import the framework-specific builtin module.  On
+    ModuleNotFoundError (dynamic/external provider with no dedicated module),
+    falls back to the generic renderer.  Any other ImportError is re-raised.
+    get_table() is called OUTSIDE the try block so errors inside the renderer
+    surface as real exceptions rather than being swallowed.
+    """
+    current = analytics_input.replace(".", "_")
+    target = f"dashboard.compliance.{current}"
+    try:
+        module = importlib.import_module(target)
+    except ModuleNotFoundError as exc:
+        if exc.name != target:
+            raise
+        from dashboard.compliance import generic as module
+    dedup_columns = ["CHECKID", "STATUS", "RESOURCEID", "STATUSEXTENDED"]
+    if "MUTED" in data.columns:
+        dedup_columns.insert(2, "MUTED")
+    data = data.drop_duplicates(subset=dedup_columns)
+    if "threatscore" in analytics_input:
+        data = get_threatscore_mean_by_pillar(data)
+    return module.get_table(data), data
+
+
 @callback(
     [
         Output("output", "children"),
@@ -292,7 +344,7 @@ def display_data(
         data.rename(columns={"TENANCYID": "ACCOUNTID"}, inplace=True)
 
     # Filter the chosen level of the CIS
-    if is_level_1:
+    if is_level_1 and "REQUIREMENTS_ATTRIBUTES_PROFILE" in data.columns:
         data = data[data["REQUIREMENTS_ATTRIBUTES_PROFILE"].str.contains("Level 1")]
 
     # Rename the column PROJECTID to ACCOUNTID for GCP
@@ -314,6 +366,9 @@ def display_data(
         data.rename(columns={"SUBSCRIPTION": "ACCOUNTID"}, inplace=True)
         data["REGION"] = "-"
 
+    # Normalize scope columns for any remaining (e.g. dynamic) provider.
+    data = _ensure_scope_columns(data)
+
     # Filter ACCOUNT
     if account_filter == ["All"]:
         updated_cloud_account_values = data["ACCOUNTID"].unique()
@@ -409,36 +464,7 @@ def display_data(
         # Check cases where the compliance start with AWS_
         if "aws_" in analytics_input:
             analytics_input = analytics_input + "_aws"
-        try:
-            current = analytics_input.replace(".", "_")
-            compliance_module = importlib.import_module(
-                f"dashboard.compliance.{current}"
-            )
-            # Build subset list based on available columns
-            dedup_columns = ["CHECKID", "STATUS", "RESOURCEID", "STATUSEXTENDED"]
-            if "MUTED" in data.columns:
-                dedup_columns.insert(2, "MUTED")
-            data = data.drop_duplicates(subset=dedup_columns)
-
-            if "threatscore" in analytics_input:
-                data = get_threatscore_mean_by_pillar(data)
-
-            table = compliance_module.get_table(data)
-        except ModuleNotFoundError:
-            table = html.Div(
-                [
-                    html.H5(
-                        "No data found for this compliance",
-                        className="card-title",
-                        style={"text-align": "left", "color": "black"},
-                    )
-                ],
-                style={
-                    "width": "99%",
-                    "margin-right": "0.8%",
-                    "margin-bottom": "10px",
-                },
-            )
+        table, data = _dispatch_compliance_renderer(data, analytics_input)
 
         df = data.copy()
         # Remove Muted rows

dashboard/pages/overview.py

@@ -1538,7 +1538,7 @@ def filter_data(
                     html.Img(src="assets/favicon.ico", className="w-5 mr-3"),
                     html.Span("Subscribe to Prowler Cloud"),
                 ],
-                href="https://prowler.pro/",
+                href="https://cloud.prowler.com/",
                 target="_blank",
                 className="text-prowler-stone-900 inline-flex px-4 py-2 text-xs font-bold uppercase transition-all rounded-lg text-gray-900 hover:bg-prowler-stone-900/10 border-solid border-1 hover:border-prowler-stone-900/10 hover:border-solid hover:border-1 border-prowler-stone-900/10",
             ),

docs/developer-guide/configurable-checks.mdx

@@ -40,76 +40,9 @@ When adding a new configurable check to Prowler, update the following files:
   # aws.awslambda_function_vpc_multi_az
   lambda_min_azs: 2
   ```
-- **Provider Schema:** Add the typed field to the provider's Pydantic schema in `prowler/config/schema/<provider>.py`. This is required: the loader validates user configs against these schemas and the shipped `config.yaml` must round-trip with zero warnings. See [Adding a parameter to the provider schema](#adding-a-parameter-to-the-provider-schema) below.
 - **Test Fixtures:** If tests depend on this configuration, add the variable to `tests/config/fixtures/config.yaml`.
 - **Documentation:** Document the new variable in the list of configurable checks in `docs/tutorials/configuration_file.md`.
 
 For a complete list of checks that already support configuration, see the [Configuration File Tutorial](/user-guide/cli/tutorials/configuration_file).
 
-## Adding a parameter to the provider schema
-
-Every provider has a typed Pydantic schema in `prowler/config/schema/`. When a config is loaded, `validate_provider_config` checks each user-supplied key against the schema, logs a warning, and drops any field that fails validation. The consumer's `.get(key, default)` then falls back to the built-in default.
-
-This catches typos in a value (for example, `0.2` typed as `20`, or `"medium"` for an enum that expects `"MEDIUM"`). It does NOT catch typos in a key name: `disalowed_regions` (one `l` missing) is treated as an unknown key and passes through untouched, because third-party check plugins legitimately rely on unknown keys being preserved. Reviewers should still check that any new key the YAML adds is named exactly the same as the field on the schema.
-
-### Where to add the field
-
-1. Open `prowler/config/schema/<provider>.py` (for example, `aws.py`).
-2. Add a field on the provider's schema class. Always make it `Optional[...] = None` so the absence of the key is valid.
-3. Apply the tightest type the value allows. Examples below.
-
-If you are introducing an entirely new provider rather than a new parameter, also add an entry mapping the provider name to its schema class in `prowler/config/schema/registry.py`. The loader uses that registry to find the schema for the provider it is loading.
-
-### Choosing the right type
-
-| Value kind | Field declaration |
-|---|---|
-| Boolean toggle | `Optional[bool] = None` |
-| Strictly positive integer (days, counts) | `Optional[int] = Field(default=None, gt=0)` |
-| Fraction in 0..1 (threshold) | `Optional[float] = Field(default=None, ge=0.0, le=1.0)` |
-| Closed set of strings | `Optional[Literal["A", "B", "C"]] = None` |
-| Free-form string | `Optional[str] = None` |
-| List of strings or ints | `Optional[list[str]] = None` |
-
-Prefer `Literal[...]` over `str` whenever the value is one of a known set. Prefer `Field(gt=0)` over `int` whenever zero or negative would be nonsensical. The point of the schema is to catch real-world mistakes that previously passed silently.
-
-### Custom validators (only when needed)
-
-If the value has structural rules beyond type and range, add a `field_validator`. Examples already in `aws.py`:
-
-- `_validate_port_range` rejects ports outside `0..65535`.
-- `_validate_account_ids` rejects anything that isn't a 12-digit AWS account ID.
-- `_validate_trusted_ips` rejects entries that aren't a valid IP or CIDR.
-
-Raise `ValueError` from the validator. The framework converts the error into a warning and drops the offending key.
-
-### Example: adding a new parameter
-
-Say a new check needs `max_iam_role_session_hours`, a strictly positive integer that defaults to 12 in code.
-
-1. **Schema** (`prowler/config/schema/aws.py`):
-    ```python
-    # IAM
-    max_iam_role_session_hours: Optional[int] = Field(default=None, gt=0)
-    ```
-2. **Shipped config** (`prowler/config/config.yaml`):
-    ```yaml
-    # aws.iam_role_session_duration_within_limit
-    max_iam_role_session_hours: 12
-    ```
-3. **Consumer** (the check):
-    ```python
-    max_hours = iam_client.audit_config.get("max_iam_role_session_hours", 12)
-    ```
-4. **Tests** in `tests/config/schema/aws_schema_test.py`:
-    - one test for a valid value that round-trips,
-    - one test for an invalid value (zero, negative, wrong type) that is dropped.
-
-### What the loader guarantees
-
-- **Unknown keys pass through.** Third-party check plugins can introduce arbitrary keys without schema edits; they will not be filtered.
-- **Invalid values never crash the run.** They produce a single warning per field and the key is dropped.
-- **Coerced values are normalized.** A YAML-quoted `"180"` for an `int` field arrives downstream as the integer `180`.
-- **The shipped `config.yaml` must round-trip cleanly.** The integration test `test_shipped_default_config_loads_without_warnings` will fail if a key is added to the YAML without a matching schema field, so the two stay in sync.
-
 This approach ensures that checks are easily configurable, making Prowler highly adaptable to different environments and requirements.

prowler/CHANGELOG.md

@@ -2,10 +2,11 @@
 
 All notable changes to the **Prowler SDK** are documented in this file.
 
-## [5.30.0] (Prowler UNRELEASED)
+## [5.30.0] (Prowler v5.30.0)
 
 ### 🚀 Added
 
+- DISA Okta IDaaS STIG V1R2 compliance framework for the Okta provider, with a dedicated CSV output formatter and terminal summary table [(#11428)](https://github.com/prowler-cloud/prowler/pull/11428)
 - `sagemaker_models_monitor_enabled` check for AWS provider, verifying that each SageMaker monitoring schedule is in the `Scheduled` state so data and model drift is actively detected [(#11278)](https://github.com/prowler-cloud/prowler/pull/11278)
 - DORA (Digital Operational Resilience Act, Regulation (EU) 2022/2554) universal compliance framework with AWS provider coverage across the five DORA pillars [(#11131)](https://github.com/prowler-cloud/prowler/pull/11131)
 - Okta authenticator and password policy checks for STIG-aligned hardening requirements [(#11465)](https://github.com/prowler-cloud/prowler/pull/11465)
@@ -19,6 +20,8 @@ All notable changes to the **Prowler SDK** are documented in this file.
 - `entra_service_principal_privileged_role_no_owners` check for M365 provider, failing when a service principal with a permanent Tier 0 directory role has owners on the service principal or its parent app registration [(#11070)](https://github.com/prowler-cloud/prowler/issues/11070)
 - `kms_key_rotation_max_90_days` check for GCP provider, verifying KMS customer-managed keys are rotated every 90 days or less in line with the CIS Benchmark [(#11516)](https://github.com/prowler-cloud/prowler/pull/11516)
 - `exchange_mailbox_primary_smtp_uses_custom_domain` check for M365 provider [(#11215)](https://github.com/prowler-cloud/prowler/pull/11215)
+- `bedrock_agent_role_least_privilege` check for AWS provider, flagging Bedrock Agent execution roles with full-access managed policies, broad `Resource:*` inline statements, or missing permissions boundaries [(#11335)](https://github.com/prowler-cloud/prowler/pull/11335)
+- STACKIT ObjectStorage service with Object Lock, default retention policy, and access key expiration checks [(#11397)](https://github.com/prowler-cloud/prowler/pull/11397)
 
 ### 🐞 Fixed
 
@@ -26,6 +29,12 @@ All notable changes to the **Prowler SDK** are documented in this file.
 - `entra_users_mfa_capable` no longer flags pre-provisioned users with future `employeeHireDate`; future-hire date comparisons now tolerate naive datetimes [(#11511)](https://github.com/prowler-cloud/prowler/pull/11511)
 - M365 Admin Center group enumeration now follows Microsoft Graph pagination so group-scoped checks include groups beyond the first page [(#11510)](https://github.com/prowler-cloud/prowler/pull/11510)
 - GCP `kms_key_rotation_enabled` check now only verifies that automatic key rotation is enabled (any interval) instead of enforcing a 90-day period, resolving the mismatch between the check and its documentation; the CIS, Prowler ThreatScore, and CCC requirements that mandate a 90-day maximum were remapped to the new `kms_key_rotation_max_90_days` check [(#11516)](https://github.com/prowler-cloud/prowler/pull/11516)
+- AWS CloudWatch log metric filter checks now validate `filterPattern` clauses regardless of order [(#11345)](https://github.com/prowler-cloud/prowler/pull/11345)
+- AWS `bedrock_api_key_no_long_term_credentials` now applies severity per finding (never-expires keys correctly flag as critical, no leak across findings) and aligns title and wording with AWS guidance to prefer short-term Bedrock API keys [(#11526)](https://github.com/prowler-cloud/prowler/pull/11526)
+
+### 🔐 Security
+
+- `dulwich` from 0.23.0 to 1.2.5 and `pyjwt` from 2.12.1 to 2.13.0, patching `GHSA-897w-fcg9-f6xj` (arbitrary file write) and `PYSEC-2026-179` (HMAC/JWK key confusion) [(#11499)](https://github.com/prowler-cloud/prowler/pull/11499)
 
 ---
 
@@ -38,10 +47,6 @@ All notable changes to the **Prowler SDK** are documented in this file.
 - Jira integration no longer fails with `400 INVALID_INPUT` when a finding has empty fields [(#11474)](https://github.com/prowler-cloud/prowler/pull/11474)
 - GCP `iam_service_account_unused` now passes disabled service accounts instead of failing them, since a disabled account cannot authenticate or be used [(#11467)](https://github.com/prowler-cloud/prowler/pull/11467)
 
-### 🔐 Security
-
-- `dulwich` from 0.23.0 to 1.2.5 and `pyjwt` from 2.12.1 to 2.13.0, patching `GHSA-897w-fcg9-f6xj` (arbitrary file write) and `PYSEC-2026-179` (HMAC/JWK key confusion) flagged by osv-scanner [(#11499)](https://github.com/prowler-cloud/prowler/pull/11499)
-
 ---
 
 ## [5.29.1] (Prowler v5.29.1)
@@ -128,7 +133,6 @@ All notable changes to the **Prowler SDK** are documented in this file.
 - `entra_service_principal_no_secrets_for_permanent_tier0_roles` check for M365 provider [(#10788)](https://github.com/prowler-cloud/prowler/pull/10788)
 - `iam_user_access_not_stale_to_sagemaker` check for AWS provider with configurable `max_unused_sagemaker_access_days` (default 90) [(#11000)](https://github.com/prowler-cloud/prowler/pull/11000)
 - `cloudtrail_bedrock_logging_enabled` check for AWS provider [(#10858)](https://github.com/prowler-cloud/prowler/pull/10858)
-- Per-provider scan configuration schema with bounds validation that drops out-of-range values with a warning on config load [(#11518)](https://github.com/prowler-cloud/prowler/pull/11518)
 - Okta provider with OAuth 2.0 authentication and `signon_global_session_idle_timeout_15min` check [(#11079)](https://github.com/prowler-cloud/prowler/pull/11079)
 - `sagemaker_domain_sso_configured` check for AWS provider [(#11094)](https://github.com/prowler-cloud/prowler/pull/11094)
 - Scaleway provider with `iam_api_keys_no_root_owned` check [(#11166)](https://github.com/prowler-cloud/prowler/pull/11166)

prowler/__main__.py

@@ -19,7 +19,7 @@ from prowler.config.config import (
     orange_color,
     sarif_file_suffix,
 )
-from prowler.lib.banner import print_banner
+from prowler.lib.banner import print_banner, print_prowler_cloud_banner
 from prowler.lib.check.check import (
     exclude_checks_to_run,
     exclude_services_to_run,
@@ -102,6 +102,9 @@ from prowler.lib.outputs.compliance.mitre_attack.mitre_attack_azure import (
     AzureMitreAttack,
 )
 from prowler.lib.outputs.compliance.mitre_attack.mitre_attack_gcp import GCPMitreAttack
+from prowler.lib.outputs.compliance.okta_idaas_stig.okta_idaas_stig_okta import (
+    OktaIDaaSSTIG,
+)
 from prowler.lib.outputs.compliance.prowler_threatscore.prowler_threatscore_alibaba import (
     ProwlerThreatScoreAlibaba,
 )
@@ -199,7 +202,7 @@ def prowler():
 
     if not args.no_banner:
         legend = args.verbose or getattr(args, "fixer", None)
-        print_banner(legend)
+        print_banner(legend, provider)
 
     # We treat the compliance framework as another output format
     if compliance_framework:
@@ -1314,6 +1317,33 @@ def prowler():
                 )
                 generated_outputs["compliance"].append(generic_compliance)
                 generic_compliance.batch_write_data_to_file()
+    elif provider == "okta":
+        for compliance_name in input_compliance_frameworks:
+            if compliance_name.startswith("okta_idaas_stig"):
+                # Generate Okta IDaaS STIG Finding Object
+                filename = (
+                    f"{output_options.output_directory}/compliance/"
+                    f"{output_options.output_filename}_{compliance_name}.csv"
+                )
+                okta_idaas_stig = OktaIDaaSSTIG(
+                    findings=finding_outputs,
+                    compliance=bulk_compliance_frameworks[compliance_name],
+                    file_path=filename,
+                )
+                generated_outputs["compliance"].append(okta_idaas_stig)
+                okta_idaas_stig.batch_write_data_to_file()
+            else:
+                filename = (
+                    f"{output_options.output_directory}/compliance/"
+                    f"{output_options.output_filename}_{compliance_name}.csv"
+                )
+                generic_compliance = GenericCompliance(
+                    findings=finding_outputs,
+                    compliance=bulk_compliance_frameworks[compliance_name],
+                    file_path=filename,
+                )
+                generated_outputs["compliance"].append(generic_compliance)
+                generic_compliance.batch_write_data_to_file()
     else:
         # Dynamic fallback: any external/custom provider
         try:
@@ -1446,6 +1476,10 @@ def prowler():
                     f"\nDetailed compliance results are in {Fore.YELLOW}{output_options.output_directory}/compliance/{Style.RESET_ALL}\n"
                 )
 
+    # Promote Prowler Cloud as the last thing the user sees after the results
+    if not args.no_banner and not args.only_logs:
+        print_prowler_cloud_banner(provider)
+
     # If custom checks were passed, remove the modules
     if checks_folder:
         remove_custom_checks_module(checks_folder, provider)

prowler/compliance/okta/okta_idaas_stig_v1r2_okta.json

@@ -0,0 +1,638 @@
+{
+  "Framework": "Okta-IDaaS-STIG",
+  "Name": "DISA Okta Identity as a Service (IDaaS) STIG V1R2",
+  "Version": "1R2",
+  "Provider": "Okta",
+  "Description": "Defense Information Systems Agency (DISA) Security Technical Implementation Guide (STIG) for Okta Identity as a Service (IDaaS), Version 1 Release 2 (Benchmark Date: 05 Jan 2026).",
+  "Requirements": [
+    {
+      "Id": "OKTA-APP-000020",
+      "Name": "Okta must log out a session after a 15-minute period of inactivity.",
+      "Description": "A session timeout lock is a temporary action taken when a user stops work and moves away from the immediate physical vicinity of the information system but does not log out because of the temporary nature of the absence. Rather than relying on the user to manually lock their application session prior to vacating the vicinity, applications must be able to identify when a user's application session has idled and take action to initiate the session lock. The session lock is implemented at the point where session activity can be determined and/or controlled. This is typically at the operating system level and results in a system lock. However, it may be at the application level where the application interface window is secured instead. Satisfies: SRG-APP-000003, SRG-APP-000190",
+      "Checks": [
+        "signon_global_session_idle_timeout_15min"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273186r1098825_rule",
+          "StigID": "OKTA-APP-000020",
+          "CCI": [
+            "CCI-000057",
+            "CCI-001133"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Global Session Policy. 2. In the Default Policy, verify a rule is configured at Priority 1 that is not named \"Default Rule\". 3. Click the edit icon next to the Priority 1 rule. 4. Verify the \"Maximum Okta global session idle time\" is set to 15 minutes. If \"Maximum Okta global session idle time\" is not set to 15 minutes, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Global Session Policy. 2. Select the Default Policy. 3. In the Rules table, make these updates: - Click \"Add rule\". - Set \"Maximum Okta global session idle time\" to 15 minutes."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000025",
+      "Name": "The Okta Admin Console must log out a session after a 15-minute period of inactivity.",
+      "Description": "A session timeout lock is a temporary action taken when a user stops work and moves away from the immediate physical vicinity of the information system but does not log out because of the temporary nature of the absence. Rather than relying on the user to manually lock their application session prior to vacating the vicinity, applications must be able to identify when a user's application session has idled and take action to initiate the session lock. The session lock is implemented at the point where session activity can be determined and/or controlled. This is typically at the operating system level and results in a system lock. However, it may be at the application level where the application interface window is secured instead.",
+      "Checks": [
+        "application_admin_console_session_idle_timeout_15min"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273187r1098828_rule",
+          "StigID": "OKTA-APP-000025",
+          "CCI": [
+            "CCI-000057"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Applications >> Applications >> Okta Admin Console. 2. In the Sign On tab, under \"Okta Admin Console session\", verify the \"Maximum app session idle time\" is set to 15 minutes. If the \"Maximum app session idle time\" is not set to 15 minutes, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Applications >> Applications >> Okta Admin Console. 2. In the Sign On tab, under \"Okta Admin Console session\", set the \"Maximum app session idle time\" to 15 minutes."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000090",
+      "Name": "Okta must automatically disable accounts after a 35-day period of account inactivity.",
+      "Description": "Attackers that are able to exploit an inactive account can potentially obtain and maintain undetected access to an application. Owners of inactive accounts will not notice if unauthorized access to their user account has been obtained. Applications must track periods of user inactivity and disable accounts after 35 days of inactivity. Such a process greatly reduces the risk that accounts will be hijacked, leading to a data compromise. To address access requirements, many application developers choose to integrate their applications with enterprise-level authentication/access mechanisms that meet or exceed access control policy requirements. Such integration allows the application developer to off-load those access control functions and focus on core application features and functionality. This policy does not apply to emergency accounts or infrequently used accounts. Infrequently used accounts are local login administrator accounts used by system administrators when network or normal login/access is not available. Emergency accounts are administrator accounts created in response to crisis situations. Satisfies: SRG-APP-000025, SRG-APP-000163, SRG-APP-000700",
+      "Checks": [
+        "user_inactivity_automation_35d_enabled"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273188r1098831_rule",
+          "StigID": "OKTA-APP-000090",
+          "CCI": [
+            "CCI-000017",
+            "CCI-000795",
+            "CCI-003627"
+          ],
+          "CheckText": "If Okta Services rely on external directory services for user sourcing, this is not applicable, and the connected directory services must perform this function. Go to Workflows >> Automations and verify that an Automation has been created to disable accounts after 35 days of inactivity. If the Okta configuration does not automatically disable accounts after a 35-day period of account inactivity, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Workflow >> Automations and select \"Add Automation\". 2. Create a name for the Automation (e.g., \"User Inactivity\"). 3. Click \"Add Condition\" and select \"User Inactivity in Okta\". 4. In the duration field, enter 35 days and click \"Save\". 5 Click the edit button next to \"Select Schedule\". 6. Configure the \"Schedule\" field for \"Run Daily\" and set the \"Time\" field to an organizationally defined time to run this automation. Click \"Save\". 7. Click the edit button next to \"Select group membership\". 8. In the \"Applies to\" field, select the group \"Everyone\" by typing it into the field. Click \"Save\". 9. Click \"Add Action\" and select \"Change User lifecycle state in Okta\". 10. In the \"Change user state to\" field, select \"Suspended\" and click \"Save\". 11. Click the \"Inactive\" button near the top of the section screen and select \"Activate\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000170",
+      "Name": "Okta must enforce the limit of three consecutive invalid login attempts by a user during a 15-minute time period.",
+      "Description": "By limiting the number of failed login attempts, the risk of unauthorized system access via user password guessing, otherwise known as brute forcing, is reduced. Limits are imposed by locking the account. Satisfies: SRG-APP-000065, SRG-APP-000345",
+      "Checks": [
+        "authenticator_password_lockout_threshold_3"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273189r1098834_rule",
+          "StigID": "OKTA-APP-000170",
+          "CCI": [
+            "CCI-000044",
+            "CCI-002238"
+          ],
+          "CheckText": "If Okta Services rely on external directory services for user sourcing, this check is not applicable, and the connected directory services must perform this function. From the Admin Console: 1. Go to Security >> Authenticators. 2. Click the \"Actions\" button next to \"Password\" and select \"Edit\". 3. For each Password Policy, verify the \"Lock Out\" section has the following values: - \"Lock out after 3 unsuccessful attempts\" is checked. - The value is set to \"3\". If Okta Services are not configured to automatically lock user accounts after three consecutive invalid login attempts, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Authenticators. 2. Click the \"Actions\" button next to \"Password\" and select \"Edit\". 3. For each Password Policy, ensure the \"Lock Out\" section has the following values: - \"Lock out after 3 unsuccessful attempts\" is checked. - The value is set to \"3\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000180",
+      "Name": "The Okta Dashboard application must be configured to allow authentication only via non-phishable authenticators.",
+      "Description": "Requiring the use of non-phishable authenticators protects against brute force/password dictionary attacks. This provides a better level of security while removing the need to lock out accounts after three attempts in 15 minutes.",
+      "Checks": [
+        "application_dashboard_phishing_resistant_authentication"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273190r1099763_rule",
+          "StigID": "OKTA-APP-000180",
+          "CCI": [
+            "CCI-000044"
+          ],
+          "CheckText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Dashboard\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"Possession factor constraints are\" section, verify the \"Phishing resistant\" box is checked. This will ensure that only phishing-resistant factors are used to access the Okta Dashboard. If in the \"Possession factor constraints are\" section the \"Phishing resistant\" box is not checked, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Dashboard\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"Possession factor constraints are\" section, ensure the \"Phishing resistant\" box is checked."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000190",
+      "Name": "The Okta Admin Console application must be configured to allow authentication only via non-phishable authenticators.",
+      "Description": "Requiring the use of non-phishable authenticators protects against brute force/password dictionary attacks. This provides a better level of security while removing the need to lock out accounts after three attempts in 15 minutes.",
+      "Checks": [
+        "application_admin_console_phishing_resistant_authentication"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273191r1099764_rule",
+          "StigID": "OKTA-APP-000190",
+          "CCI": [
+            "CCI-000044"
+          ],
+          "CheckText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Admin Console\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"Possession factor constraints are\" section, verify the \"Phishing resistant\" box is checked. This will ensure that only phishing-resistant factors are used to access the Okta Dashboard. If in the \"Possession factor constraints are\" section the \"Phishing resistant\" box is not checked, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Admin Console\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"Possession factor constraints are\" section, ensure the \"Phishing resistant\" box is checked."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000200",
+      "Name": "Okta must display the Standard Mandatory DOD Notice and Consent Banner before granting access to the application.",
+      "Description": "Display of the DOD-approved use notification before granting access to the application ensures that privacy and security notification verbiage used is consistent with applicable federal laws, Executive Orders, directives, policies, regulations, standards, and guidance. System use notifications are required only for access via login interfaces with human users and are not required when such human interfaces do not exist. The banner must be formatted in accordance with DTM-08-060. Use the following verbiage for applications that can accommodate banners of 1300 characters: \"You are accessing a U.S. Government (USG) Information System (IS) that is provided for USG-authorized use only. By using this IS (which includes any device attached to this IS), you consent to the following conditions: -The USG routinely intercepts and monitors communications on this IS for purposes including, but not limited to, penetration testing, COMSEC monitoring, network operations and defense, personnel misconduct (PM), law enforcement (LE), and counterintelligence (CI) investigations. -At any time, the USG may inspect and seize data stored on this IS. -Communications using, or data stored on, this IS are not private, are subject to routine monitoring, interception, and search, and may be disclosed or used for any USG-authorized purpose. -This IS includes security measures (e.g., authentication and access controls) to protect USG interests--not for your personal benefit or privacy. -Notwithstanding the above, using this IS does not constitute consent to PM, LE or CI investigative searching or monitoring of the content of privileged communications, or work product, related to personal representation or services by attorneys, psychotherapists, or clergy, and their assistants. Such communications and work product are private and confidential. See User Agreement for details.\" Use the following verbiage for operating systems that have severe limitations on the number of characters that can be displayed in the banner: \"I've read & consent to terms in IS user agreem't.\" Satisfies: SRG-APP-000068, SRG-APP-000069, SRG-APP-000070",
+      "Checks": [
+        "signon_dod_warning_banner_configured"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273192r1098843_rule",
+          "StigID": "OKTA-APP-000200",
+          "CCI": [
+            "CCI-000048",
+            "CCI-000050",
+            "CCI-001384",
+            "CCI-001385",
+            "CCI-001386",
+            "CCI-001387",
+            "CCI-001388"
+          ],
+          "CheckText": "Attempt to log in to the Okta tenant and verify the DOD-approved warning banner is in place. If the required warning banner is not present and complete, this is a finding.",
+          "FixText": "Follow the supplemental instructions in the \"Okta DOD Warning Banner Configuration Guide\" provided with this STIG package."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000560",
+      "Name": "The Okta Admin Console application must be configured to use multifactor authentication.",
+      "Description": "Without the use of multifactor authentication, the ease of access to privileged functions is greatly increased. Multifactor authentication requires using two or more factors to achieve authentication. Factors include: (i) something a user knows (e.g., password/PIN); (ii) something a user has (e.g., cryptographic identification device, token); or (iii) something a user is (e.g., biometric). A privileged account is defined as an information system account with authorizations of a privileged user. Network access is defined as access to an information system by a user (or a process acting on behalf of a user) communicating through a network (e.g., local area network, wide area network, or the internet). Satisfies: SRG-APP-000149, SRG-APP-000154",
+      "Checks": [
+        "application_admin_console_mfa_required"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT I (High)",
+          "Severity": "high",
+          "RuleID": "SV-273193r1098846_rule",
+          "StigID": "OKTA-APP-000560",
+          "CCI": [
+            "CCI-000765",
+            "CCI-004046"
+          ],
+          "CheckText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Admin Console\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"User must authenticate with\" field, verify that either \"Password/IdP + Another factor\" or \"Any 2 factor types\" is selected. If either of these settings is incorrect, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Admin Console\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"User must authenticate with\" field, select either \"Password/IdP + Another factor\" or \"Any 2 factor types\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000570",
+      "Name": "The Okta Dashboard application must be configured to use multifactor authentication.",
+      "Description": "To ensure accountability and prevent unauthenticated access, nonprivileged users must use multifactor authentication to prevent potential misuse and compromise of the system. Multifactor authentication uses two or more factors to achieve authentication. Factors include: (i) Something you know (e.g., password/PIN); (ii) Something you have (e.g., cryptographic identification device, token); or (iii) Something you are (e.g., biometric). A nonprivileged account is any information system account with authorizations of a nonprivileged user. Network access is any access to an application by a user (or process acting on behalf of a user) where the access is obtained through a network connection. Applications integrating with the DOD Active Directory and using the DOD CAC are examples of compliant multifactor authentication solutions. Satisfies: SRG-APP-000150, SRG-APP-000155",
+      "Checks": [
+        "application_dashboard_mfa_required"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT I (High)",
+          "Severity": "high",
+          "RuleID": "SV-273194r1098849_rule",
+          "StigID": "OKTA-APP-000570",
+          "CCI": [
+            "CCI-000766",
+            "CCI-004046"
+          ],
+          "CheckText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Dashboard\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"User must authenticate with\" field, verify that either \"Password/IdP + Another factor\" or \"Any 2 factor types\" is selected. If either of these settings is incorrect, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Authentication Policies. 2. Click the \"Okta Dashboard\" policy. 3. Click the \"Actions\" button next to the top rule and select \"Edit\". 4. In the \"User must authenticate with\" field, select either \"Password/IdP + Another factor\" or \"Any 2 factor types\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000650",
+      "Name": "Okta must enforce a minimum 15-character password length.",
+      "Description": "Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks. Password length is one factor of several that helps to determine strength and how long it takes to crack a password. The shorter the password, the lower the number of possible combinations that need to be tested before the password is compromised. Use of more characters in a password helps to exponentially increase the time and/or resources required to compromise the password.",
+      "Checks": [
+        "authenticator_password_minimum_length_15"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273195r1098852_rule",
+          "StigID": "OKTA-APP-000650",
+          "CCI": [
+            "CCI-004066"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy, verify the \"Minimum Length\" field is set to at least \"15\" characters. If any policy is not set to at least \"15\", this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set the \"Minimum Length\" field to at least \"15\" characters."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000670",
+      "Name": "Okta must enforce password complexity by requiring that at least one uppercase character be used.",
+      "Description": "Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks. Password complexity is one factor of several that determine how long it takes to crack a password. The more complex the password is, the greater the number of possible combinations that need to be tested before the password is compromised.",
+      "Checks": [
+        "authenticator_password_complexity_uppercase"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273196r1098855_rule",
+          "StigID": "OKTA-APP-000670",
+          "CCI": [
+            "CCI-004066"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy, verify \"Upper case letter\" is checked. For each policy, if \"Upper case letter\" is not checked, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set \"Upper case letter\" to checked."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000680",
+      "Name": "Okta must enforce password complexity by requiring that at least one lowercase character be used.",
+      "Description": "Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks. Password complexity is one factor of several that determine how long it takes to crack a password. The more complex the password, the greater the number of possible combinations that need to be tested before the password is compromised.",
+      "Checks": [
+        "authenticator_password_complexity_lowercase"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273197r1098858_rule",
+          "StigID": "OKTA-APP-000680",
+          "CCI": [
+            "CCI-004066"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy, verify \"Lower case letter\" is checked. For each policy, if \"Lower case letter\" is not checked, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set \"Lower case letter\" to checked."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000690",
+      "Name": "Okta must enforce password complexity by requiring that at least one numeric character be used.",
+      "Description": "Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks. Password complexity is one factor of several that determine how long it takes to crack a password. The more complex the password, the greater the number of possible combinations that need to be tested before the password is compromised.",
+      "Checks": [
+        "authenticator_password_complexity_number"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273198r1098861_rule",
+          "StigID": "OKTA-APP-000690",
+          "CCI": [
+            "CCI-004066"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy, verify \"Number (0-9)\" is checked. For each policy, if \"Number (0-9)\" is not checked, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set \"Number (0-9)\" to checked."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000700",
+      "Name": "Okta must enforce password complexity by requiring that at least one special character be used.",
+      "Description": "Use of a complex password helps to increase the time and resources required to compromise the password. Password complexity, or strength, is a measure of the effectiveness of a password in resisting attempts at guessing and brute-force attacks. Password complexity is one factor in determining how long it takes to crack a password. The more complex the password, the greater the number of possible combinations that need to be tested before the password is compromised. Special characters are not alphanumeric. Examples include: ~ ! @ # $ % ^ *.",
+      "Checks": [
+        "authenticator_password_complexity_symbol"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273199r1098864_rule",
+          "StigID": "OKTA-APP-000700",
+          "CCI": [
+            "CCI-004066"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy, verify \"Symbol (e.g., !@#$%^&*)\" is checked. For each policy, if \"Symbol (e.g., !@#$%^&*)\" is not checked, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set \"Symbol (e.g., !@#$%^&*)\" to checked."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000740",
+      "Name": "Okta must enforce 24 hours/one day as the minimum password lifetime.",
+      "Description": "Enforcing a minimum password lifetime helps prevent repeated password changes to defeat the password reuse or history enforcement requirement. Restricting this setting limits the user's ability to change their password. Passwords must be changed at specific policy-based intervals; however, if the application allows the user to immediately and continually change their password, it could be changed repeatedly in a short period of time to defeat the organization's policy regarding password reuse. Satisfies: SRG-APP-000173, SRG-APP-000870",
+      "Checks": [
+        "authenticator_password_minimum_age_24h"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273200r1098867_rule",
+          "StigID": "OKTA-APP-000740",
+          "CCI": [
+            "CCI-004066"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy, verify \"Minimum password age is XX hours\" is set to at least \"24\". For each policy, if \"Minimum password age is XX hours\" is not set to at least \"24\", this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set \"Minimum password age is XX hours\" to at least \"24\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-000745",
+      "Name": "Okta must enforce a 60-day maximum password lifetime restriction.",
+      "Description": "Any password, no matter how complex, can eventually be cracked. Therefore, passwords must be changed at specific intervals. One method of minimizing this risk is to use complex passwords and periodically change them. If the application does not limit the lifetime of passwords and force users to change their passwords, there is the risk that the system and/or application passwords could be compromised. This requirement does not include emergency administration accounts, which are meant for access to the application in case of failure. These accounts are not required to have maximum password lifetime restrictions.",
+      "Checks": [
+        "authenticator_password_maximum_age_60d"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273201r1098870_rule",
+          "StigID": "OKTA-APP-000745",
+          "CCI": [
+            "CCI-004066"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy, verify \"Password expires after XX days\" is set to \"60\". For each policy, if \"Password expires after XX days\" is not set to \"60\", this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set \"Password expires after XX days\" to \"60\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-001430",
+      "Name": "Okta must off-load audit records onto a central log server.",
+      "Description": "Information stored in one location is vulnerable to accidental or incidental deletion or alteration. Off-loading is a common process in information systems with limited audit storage capacity. Satisfies: SRG-APP-000358, SRG-APP-000080, SRG-APP-000125",
+      "Checks": [
+        "systemlog_streaming_enabled"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT I (High)",
+          "Severity": "high",
+          "RuleID": "SV-273202r1099766_rule",
+          "StigID": "OKTA-APP-001430",
+          "CCI": [
+            "CCI-001851",
+            "CCI-000166",
+            "CCI-001348"
+          ],
+          "CheckText": "From the Admin Console: 1. Go to Reports >> Log Streaming. 2. Verify that a Log Stream connection is configured and active. Alternately, interview the information system security manager (ISSM) and verify that an external Security Information and Event Management (SIEM) system is pulling Okta logs via an Application Programming Interface (API). If either of these is not configured, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Reports >> Log Streaming. 2. Select either \"AWS EventBridge\" or \"Splunk Cloud\" and click \"Next\". 3. Complete the necessary fields and click \"Save\". If Log Streaming is not an option because the SIEM required is not an option, customers can use the Okta Log API to export system logs in real time."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-001665",
+      "Name": "Okta must be configured to limit the global session lifetime to 18 hours.",
+      "Description": "Without reauthentication, users may access resources or perform tasks for which they do not have authorization. When applications provide the capability to change security roles or escalate the functional capability of the application, it is critical the user reauthenticate. In addition to the reauthentication requirements associated with session locks, organizations may require reauthentication of individuals and/or devices in other situations, including (but not limited to) the following circumstances. (i) When authenticators change; (ii) When roles change; (iii) When security categories of information systems change; (iv) When the execution of privileged functions occurs; (v) After a fixed period of time; or (vi) Periodically. Within the DOD, the minimum circumstances requiring reauthentication are privilege escalation and role changes.",
+      "Checks": [
+        "signon_global_session_lifetime_18h"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273203r1099958_rule",
+          "StigID": "OKTA-APP-001665",
+          "CCI": [
+            "CCI-002038"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Global Session Policy. 2. In the Default Policy, verify a rule is configured at Priority 1 that is not named \"Default Rule\". 3. Click the \"Edit\" icon next to the Priority 1 rule. 4. Verify \"Maximum Okta global session lifetime\" is set to 18 hours. If the above is not set, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Global Session Policy. 2. Select the Default Policy. 3. In the Rules table, make these updates: - Click \"Add rule\". - Set \"Maximum Okta global session lifetime\" to 18 hours."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-001670",
+      "Name": "Okta must be configured to accept Personal Identity Verification (PIV) credentials.",
+      "Description": "The use of PIV credentials facilitates standardization and reduces the risk of unauthorized access. DOD has mandated the use of the common access card (CAC) to support identity management and personal authentication for systems covered under HSPD 12, as well as a primary component of layered protection for national security systems. Satisfies: SRG-APP-000391, SRG-APP-000402, SRG-APP-000403",
+      "Checks": [
+        "authenticator_smart_card_active"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273204r1098879_rule",
+          "StigID": "OKTA-APP-001670",
+          "CCI": [
+            "CCI-001953",
+            "CCI-002009",
+            "CCI-002010"
+          ],
+          "CheckText": "From the Admin Console: 1. Go to Security >> Authenticators. 2. Verify that \"Smart Card Authenticator\" is listed and has \"Status\" listed as \"Active\". If \"Smart Card Authenticator\" is not listed or is not listed as \"Active\", this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Authenticators. 2. In the \"Setup\" tab, click \"Add authenticator\". 3. Select the configured Smart Card Identity Provider and finish configuration."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-001700",
+      "Name": "The Okta Verify application must be configured to connect only to FIPS-compliant devices.",
+      "Description": "Without device-to-device authentication, communications with malicious devices may be established. Bidirectional authentication provides stronger safeguards to validate the identity of other devices for connections that are of greater risk. Currently, DOD requires the use of AES for bidirectional authentication because it is the only FIPS-validated AES cipher block algorithm. For distributed architectures (e.g., service-oriented architectures), the decisions regarding the validation of authentication claims may be made by services separate from the services acting on those decisions. In such situations, it is necessary to provide authentication decisions (as opposed to the actual authenticators) to the services that need to act on those decisions. A local connection is any connection with a device communicating without the use of a network. A network connection is any connection with a device that communicates through a network (e.g., local area or wide area network; the internet). A remote connection is any connection with a device communicating through an external network (e.g., the internet). Because of the challenges of applying this requirement on a large scale, organizations are encouraged to apply the requirement only to those limited number (and type) of devices that truly need to support this capability.",
+      "Checks": [
+        "authenticator_okta_verify_fips_compliant"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273205r1098882_rule",
+          "StigID": "OKTA-APP-001700",
+          "CCI": [
+            "CCI-001967"
+          ],
+          "CheckText": "From the Admin Console: 1. Go to Security >> Authenticators. 2. From the \"Setup\" tab, select \"Edit Okta Verify\". 3. Review the \"FIPS Compliance\" field. If FIPS-compliant authentication is not enabled, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Authenticators. 2. From the \"Setup\" tab, select \"Edit Okta Verify\". 3. In the \"FIPS Compliance\" field, choose whether users enrolling in Okta Verify can use FIPS-compliant devices only or any device. 4. Click \"Save\" after making any changes."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-001710",
+      "Name": "Okta must be configured to disable persistent global session cookies.",
+      "Description": "If cached authentication information is out of date, the validity of the authentication information may be questionable. Satisfies: SRG-APP-000400, SRG-APP-000157",
+      "Checks": [
+        "signon_global_session_cookies_not_persistent"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273206r1098885_rule",
+          "StigID": "OKTA-APP-001710",
+          "CCI": [
+            "CCI-002007",
+            "CCI-001942"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Global Session Policy. 2. In the Default Policy, verify a rule is configured at Priority 1 that is not named \"Default Rule\". 3. Click the \"Edit\" icon next to the Priority 1 rule. 4. Verify \"Okta global session cookies persist across browser sessions\" is set to \"Disabled\". If the above it not set, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Global Session Policy. 2. Select the Default Policy. 3. In the \"Rules\" table, make these updates: - Click \"Add rule\". - Set \"Okta global session cookies persist across browser sessions\" to Disable."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-001920",
+      "Name": "Okta must be configured to use only DOD-approved certificate authorities.",
+      "Description": "Untrusted Certificate Authorities (CA) can issue certificates, but they may be issued by organizations or individuals that seek to compromise DOD systems or by organizations with insufficient security controls. If the CA used for verifying the certificate is not DOD approved, trust of this CA has not been established. The DOD will accept only PKI certificates obtained from a DOD-approved internal or external CA. Reliance on CAs for the establishment of secure sessions includes, for example, the use of Transport Layer Security (TLS) certificates. This requirement focuses on communications protection for the application session rather than for the network packet. This requirement applies to applications that use communications sessions. This includes, but is not limited to, web-based applications and Service-Oriented Architectures (SOA). Satisfies: SRG-APP-000427, SRG-APP-000910",
+      "Checks": [
+        "idp_smart_card_dod_approved_ca"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273207r1098888_rule",
+          "StigID": "OKTA-APP-001920",
+          "CCI": [
+            "CCI-002470",
+            "CCI-004909"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Identity Providers (IdPs). 2. Review the list of IdPs with \"Type\" as \"Smart Card\". If the IdP is not listed as \"Active\", this is a finding. 3. Select Actions >> Configure. 4. Under \"Certificate chain\", verify the certificate is from a DOD-approved CA. If the certificate is not from a DOD-approved CA, this is a finding.",
+          "FixText": "From the Admin Console: 1. Go to Security >> Identity Providers. 2. Click \"Add identity provider.\" 3. Click \"Smart Card IdP\". Click \"Next\". 4. Enter the name of the identity provider. 5. Build a certificate chain: - Click \"Browse\" to open a file explorer. Select the certificate file to add and click \"Open\". - To add another certificate, click \"Add Another\" and repeat step 1. - Click \"Build certificate chain\". On success, the chain and its certificates are shown. If the build failed, correct any issues and try again. - Click \"Reset certificate chain\" if replacing the current chain with a new one. 6. In \"IdP username\", select the \"idpuser.subjectAltNameUpn\" attribute. This is the attribute that stores the Electronic Data Interchange Personnel Identifier (EDIPI) on the CAC. 7. In the \"Match Against\" field, select the Okta Profile Attribute in which the EDIPI is to be stored."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-002980",
+      "Name": "Okta must validate passwords against a list of commonly used, expected, or compromised passwords.",
+      "Description": "Password-based authentication applies to passwords regardless of whether they are used in single-factor or multifactor authentication. Long passwords or passphrases are preferable over shorter passwords. Enforced composition rules provide marginal security benefits while decreasing usability. However, organizations may choose to establish certain rules for password generation (e.g., minimum character length for long passwords) under certain circumstances and can enforce this requirement in IA-5(1)(h). Account recovery can occur, for example, in situations when a password is forgotten. Cryptographically protected passwords include salted one-way cryptographic hashes of passwords. The list of commonly used, compromised, or expected passwords includes passwords obtained from previous breach corpuses, dictionary words, and repetitive or sequential characters. The list includes context-specific words, such as the name of the service, username, and derivatives thereof.",
+      "Checks": [
+        "authenticator_password_common_password_check"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273208r1099769_rule",
+          "StigID": "OKTA-APP-002980",
+          "CCI": [
+            "CCI-004058"
+          ],
+          "CheckText": "From the Admin Console: 1. Navigate to Security >> Authenticators. 2. Click the \"Actions\" button next to the Password authenticator and select \"Edit\". 3. Under the \"Password Settings\" section, verify the \"Common Password Check\" box is checked. If \"Common Password Check\" is not selected, this is a finding.",
+          "FixText": "From the Admin Console: 1. Navigate to Security >> Authenticators. 2. Click the \"Actions\" button next to the Password authenticator and select \"Edit\". 3. Under the \"Password Settings\" section, check the \"Common Password Check\" box."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-003010",
+      "Name": "Okta must prohibit password reuse for a minimum of five generations.",
+      "Description": "Password-based authentication applies to passwords regardless of whether they are used in single-factor or multifactor authentication. Long passwords or passphrases are preferable over shorter passwords. Enforced composition rules provide marginal security benefits while decreasing usability. However, organizations may choose to establish certain rules for password generation (e.g., minimum character length for long passwords) under certain circumstances and can enforce this requirement in IA-5(1)(h). Account recovery can occur, for example, in situations when a password is forgotten. Cryptographically protected passwords include salted one-way cryptographic hashes of passwords. The list of commonly used, compromised, or expected passwords includes passwords obtained from previous breach corpuses, dictionary words, and repetitive or sequential characters. The list includes context-specific words, such as the name of the service, username, and derivatives thereof.",
+      "Checks": [
+        "authenticator_password_history_5"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-273209r1098894_rule",
+          "StigID": "OKTA-APP-003010",
+          "CCI": [
+            "CCI-004061"
+          ],
+          "CheckText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password row\" and select \"Edit\". 3. For each listed policy, verify \"Enforce password history for last XX passwords\" is set to \"5\". If any policy is not set to at least \"5\", this is a finding.",
+          "FixText": "From the Admin Console: 1. Select Security >> Authenticators. 2. Click the \"Actions\" button next to the \"Password\" row and select \"Edit\". 3. For each listed policy: - Click \"Edit\". - Set \"Enforce password history for last XX passwords\" to \"5\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-003240",
+      "Name": "Okta API tokens must be configured with Network Zones to restrict authorization from known networks.",
+      "Description": "An access token is a piece of data that represents the authorization granted to a user or NPE to access specific systems or information resources. Access tokens enable controlled access to services and resources. Properly managing the lifecycle of access tokens, including their issuance, validation, and revocation, is crucial to maintaining confidentiality of data and systems. Restricting token validity to a specific audience, e.g., an application or security domain, and restricting token validity lifetimes are important practices. Access tokens are revoked or invalidated if they are compromised, lost, or are no longer needed to mitigate the risks associated with stolen or misused tokens. API tokens have the potential to be replicated or stolen (just like a password). Because of this, it is important to only allow API tokens to authenticate from known IP ranges as this limits an adversary's ability to use a token to gain access.",
+      "Checks": [
+        "apitoken_restricted_to_network_zone"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-279689r1155066_rule",
+          "StigID": "OKTA-APP-003240",
+          "CCI": [
+            "CCI-005165",
+            "CCI-000366"
+          ],
+          "CheckText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"API\" item. 2. Click the \"Tokens\" tab. 3. For each token listed, click the token name link. 4. In the \"Security\" section, verify the \"Token can be used from\" setting is mapped to a known network zone for the application calling the API. If a network zone for each API access token is not defined, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"API\" item. 2. Click the \"Tokens\" tab. 3. For each token listed, click the token name link. 4. In the \"Security\" section, click \"Edit\". 5. Set the \"Token can be used from\" setting to the known network zone for the application calling the API. 6. Click \"Save\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-003241",
+      "Name": "Okta API tokens must be created under new dedicated user accounts.",
+      "Description": "An access token is a piece of data that represents the authorization granted to a user or NPE to access specific systems or information resources. Access tokens enable controlled access to services and resources. Properly managing the lifecycle of access tokens, including their issuance, validation, and revocation, is crucial to maintaining confidentiality of data and systems. Restricting token validity to a specific audience, e.g., an application or security domain, and restricting token validity lifetimes are important practices. Access tokens are revoked or invalidated if they are compromised, lost, or are no longer needed to mitigate the risks associated with stolen or misused tokens. When API tokens are created, they inherit the permissions of the user that created them. Therefore, API tokens should only be created from dedicated accounts and permissions must be constrained to least privilege for that dedicated user account and token. No API tokens should be created using a Super Admin account.",
+      "Checks": [
+        "apitoken_not_super_admin"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-279690r1155069_rule",
+          "StigID": "OKTA-APP-003241",
+          "CCI": [
+            "CCI-005165",
+            "CCI-000366"
+          ],
+          "CheckText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"API\" item. 2. Click the \"Tokens\" tab. 3. For each token listed, verify that the Role listed is not \"Super Admin\", and that the account has been specifically created for that token. 4. Click the account name to be token to the user profile for that user. 5. Verify the user only has an administrator role (standard or customer) applied that is correctly scoped as required and documented in the Okta Access Control policy. If the token is using a Super Administrator account, or one that is not properly scoped per the Access Control policy, this is a finding. Note: If a Super Admin token is required for system operation, then this permanent finding.",
+          "FixText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"API\" item. 2. Click the \"Tokens\" tab. 3. For each token listed that has \"Super Admin\" or an improperly scoped Admin account, delete the token and create a new one with the appropriately scoped permissions. 4. Verify the application performing the API calls with the new token has been updated."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-003242",
+      "Name": "The Okta Global Session policy must be configured to allow or deny IP based access in accordance with the Access Control policy for Okta.",
+      "Description": "To mitigate the risk of unauthorized access to sensitive information by entities that have been issued certificates by DOD-approved PKIs, all DOD systems (e.g., networks, web servers, and web portals) must be properly configured to incorporate access control methods that do not rely solely on the possession of a certificate for access. Successful authentication must not automatically give an entity access to an asset or security boundary. Authorization procedures and controls must be implemented to ensure each authenticated entity also has a validated and current authorization. Authorization is the process of determining whether an entity, once authenticated, is permitted to access a specific asset. Information systems use access control policies and enforcement mechanisms to implement this requirement. Access Control policies include identity-based policies, role-based policies, and attribute-based policies. Access enforcement mechanisms include access control lists, access control matrices, and cryptography. These policies and mechanisms must be employed by the application to control access between users (or processes acting on behalf of users) and objects (e.g., devices, files, records, processes, programs, and domains) in the information system. The Okta Global Session Policy is applied at the organization level and before any application-specific authentication policies are processed. The Okta authorization package should contain an access control policy that defines IP ranges from which to either allow or deny access. This list (either as an explicit allow or explicit deny) can be implemented in the Global Session Policy.",
+      "Checks": [
+        "signon_global_session_policy_network_zone_enforced"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-279691r1155072_rule",
+          "StigID": "OKTA-APP-003242",
+          "CCI": [
+            "CCI-000213"
+          ],
+          "CheckText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"Global Session Policy\" item. 2. In the \"Policy Settings\" section, verify the \"IF User's IP is\" setting is correctly set to either allow or deny based on the organization defined policy. If the Okta Global Session Policy is not configured to restrict access to specific IP ranges, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"Global Session Policy\" item. 2. In the Policy Settings section, configure the \"IF User's IP is\" setting to correctly set the appropriate network to either allow or deny based on the Access Control Policy."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-003243",
+      "Name": "Okta must be configured with Network Zones defined to block anonymized proxies according to organizationally defined policy.",
+      "Description": "A mechanism to detect and prevent unauthorized communication flow must be configured or provided as part of the system design. If information flow is not enforced based on approved authorizations, the system may become compromised. Information flow control regulates where information is allowed to travel within a system and between interconnected systems. The flow of all application information must be monitored and controlled so it does not introduce any unacceptable risk to the systems or data. Application-specific examples of enforcement occurs in systems that employ rule sets or establish configuration settings that restrict information system services, or provide a message filtering capability based on message content (e.g., implementing key word searches or using document characteristics). Applications providing information flow control must be able to enforce approved authorizations for controlling the flow of information between interconnected systems in accordance with applicable policy. Working with the organizational CSSP, the ISSM should obtain a list of known anonymizer proxies that exist on the commercial internet. If this is not available from the CSSP, then the Okta-provided \"Enhanced dynamic zone blocklist\" should be activated.",
+      "Checks": [
+        "network_zone_block_anonymized_proxies"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-279692r1155075_rule",
+          "StigID": "OKTA-APP-003243",
+          "CCI": [
+            "CCI-001414"
+          ],
+          "CheckText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"Networks' item. 2. If the CSSP has provided a list of anonymizers to block, verify the \"IP Block list\" is configured with them. a. Click the pencil icon next to IP Block list. b. Verify the \"Gateway IPs\" section contains all of the IP ranges in the provided list. 3. If the CSSP is not able to provide a list, then implement the Okta managed list. a. Verify the \"Enhanced dynamic zone blocklist\" is set to \"Active\". If Network Zones are not configured to block anonymous proxies, this is a finding.",
+          "FixText": "From the Admin Console: 1. Select the \"Security\" menu, and then click the \"Networks\" item. 2. If the CSSP has provided a list of anonymizers to block, add the IP ranges to the \"IP Block list\". a. Click the pencil icon next to IP Block list. b. Add the IP ranges to the \"Gateway IPs\" section and click \"Save\". 3. If the CSSP is not able to provide a list, then implement the Okta managed list. a. Set the \"Enhanced dynamic zone blocklist\" to \"Active\"."
+        }
+      ]
+    },
+    {
+      "Id": "OKTA-APP-003244",
+      "Name": "For each application integrated with Okta, network zones must be defined in its authentication policy.",
+      "Description": "A mechanism to detect and prevent unauthorized communication flow must be configured or provided as part of the system design. If information flow is not enforced based on approved authorizations, the system may become compromised. Information flow control regulates where information is allowed to travel within a system and between interconnected systems. The flow of all application information must be monitored and controlled so it does not introduce any unacceptable risk to the systems or data. Application-specific examples of enforcement occurs in systems that employ rule sets or establish configuration settings that restrict information system services, or provide a message filtering capability based on message content (e.g., implementing key word searches or using document characteristics). Applications providing information flow control must be able to enforce approved authorizations for controlling the flow of information between interconnected systems in accordance with applicable policy. Each application in Okta should have a well defined access control policy that takes into account the end user network. This should be documented in the Access Control policy for each application. As an example, access to an application may be restricted to a specific location by policy. In this case, a network defining that specific location should be created.",
+      "Checks": [
+        "application_authentication_policy_network_zone_enforced"
+      ],
+      "Attributes": [
+        {
+          "Section": "CAT II (Medium)",
+          "Severity": "medium",
+          "RuleID": "SV-279693r1155078_rule",
+          "StigID": "OKTA-APP-003244",
+          "CCI": [
+            "CCI-001414"
+          ],
+          "CheckText": "For each application integrated into Okta: 1. From the Admin console, open the \"Security\" menu, and then select \"Networks\". 2. Verify the list of networks includes all necessary allow or block lists. If any application is not configured with network zones, this is a finding.",
+          "FixText": "For each application, starting at the admin console: 1. Open the \"Applications\" group from the Menu, and then click the \"Applications\" menu item. 2. Click the application name. 3. Click the \"Sign On\" tab. 4. Scroll to the \"User Authentication\" section, and then click \"Edit\". 5. Select the appropriate Authentication policy from the pull down, and then click \"Save\". 6. Click \"View Policy Details\". 7. For each nondefault rule: a. Select \"Edit\" from the Actions menu. b. In the \"IF\" section, verify the \"User is\" setting has the appropriate allow or deny range has been selected based on the Access Control policy for the application. c. Scroll down to the bottom and click \"Save\". 8. For the Catch-All rule: a. Select \"Edit\" from the Actions menu. b. Scroll down to the \"Then\" section. c. For the \"Access is\" setting, select \"Denied\", and then click \"Save\"."
+        }
+      ]
+    }
+  ]
+}

prowler/config/config.py

@@ -49,7 +49,7 @@ class _MutableTimestamp:
 
 timestamp = _MutableTimestamp(datetime.today())
 timestamp_utc = _MutableTimestamp(datetime.now(timezone.utc))
-prowler_version = "5.30.0"
+prowler_version = "5.30.1"
 html_logo_url = "https://github.com/prowler-cloud/prowler/"
 square_logo_img = "https://raw.githubusercontent.com/prowler-cloud/prowler/dc7d2d5aeb92fdf12e8604f42ef6472cd3e8e889/docs/img/prowler-logo-black.png"
 aws_logo = "https://user-images.githubusercontent.com/38561120/235953920-3e3fba08-0795-41dc-b480-9bea57db9f2e.png"
@@ -288,11 +288,6 @@ def load_and_validate_config_file(provider: str, config_file_path: str) -> dict:
     Returns:
         dict: The configuration dictionary for the specified provider.
     """
-    # Imported lazily to avoid an import cycle: schemas may eventually want to
-    # import from prowler.config.config (e.g. for shared constants).
-    from prowler.config.schema.registry import SCHEMAS
-    from prowler.config.schema.validator import validate_provider_config
-
     try:
         with open(config_file_path, "r", encoding=encoding_format_utf_8) as f:
             config_file = yaml.safe_load(f)
@@ -318,11 +313,7 @@ def load_and_validate_config_file(provider: str, config_file_path: str) -> dict:
             else:
                 config = {}
 
-            return validate_provider_config(
-                provider=provider,
-                raw=config,
-                schema_cls=SCHEMAS.get(provider),
-            )
+            return config
 
     except FileNotFoundError as error:
         logger.error(

prowler/config/scan_config_schema.py

@@ -1,106 +0,0 @@
-"""Bridge between the Pydantic-based provider schemas in
-`prowler.config.schema` and the Prowler App backend (Django) + UI.
-
-The SDK runtime is intentionally LENIENT: invalid keys are dropped with a
-warning and downstream checks fall back to their defaults
-(`prowler.config.schema.validator.validate_provider_config`).
-
-The Prowler App, however, needs to surface those errors to the user when
-they save a Scan Config from the UI, and to expose the schema as JSON so
-the UI can validate live with `ajv`. This module provides:
-
-- `validate_scan_config(payload)` — STRICT: returns a list of
-  `{path, message}` errors without silently dropping anything. The DRF
-  serializer (`api/.../v1/serializers.py:validate_scan_config_payload`)
-  turns each entry into a `ValidationError`.
-
-- `SCAN_CONFIG_SCHEMA` — aggregated JSON Schema derived from the Pydantic
-  models via `model_json_schema()`. Served by the `/scan-configs/schema`
-  endpoint and consumed by the UI editor for in-editor live validation.
-"""
-
-from typing import Any
-
-from pydantic import ValidationError
-
-from prowler.config.schema.registry import SCHEMAS
-
-
-def _format_loc(loc: tuple) -> str:
-    """Render a Pydantic error location as `key[idx].nested`."""
-    parts: list[str] = []
-    for piece in loc:
-        if isinstance(piece, int):
-            if parts:
-                parts[-1] = f"{parts[-1]}[{piece}]"
-            else:
-                parts.append(f"[{piece}]")
-        else:
-            parts.append(str(piece))
-    return ".".join(parts) if parts else "<root>"
-
-
-def validate_scan_config(payload: Any) -> list[dict]:
-    """Validate a scan config payload against the registered provider schemas.
-
-    Strict by design: every Pydantic violation surfaces as a `{path, message}`
-    entry so the caller can decide how to present it. Unknown provider
-    sections are accepted (consistent with `additionalProperties: True` at
-    the top level — the SDK simply has no opinion on them).
-    """
-    if not isinstance(payload, dict):
-        return [
-            {
-                "path": "<root>",
-                "message": "Scan config must be a mapping with provider sections.",
-            }
-        ]
-
-    errors: list[dict] = []
-    for provider, section in payload.items():
-        schema_cls = SCHEMAS.get(provider)
-        if schema_cls is None:
-            # Unknown provider type: tolerated. The SDK will simply ignore it.
-            continue
-        if not isinstance(section, dict):
-            errors.append(
-                {
-                    "path": str(provider),
-                    "message": "section must be a mapping.",
-                }
-            )
-            continue
-        try:
-            schema_cls.model_validate(section)
-        except ValidationError as exc:
-            for err in exc.errors():
-                loc = err.get("loc") or ()
-                path = _format_loc((str(provider), *loc))
-                errors.append(
-                    {
-                        "path": path,
-                        "message": err.get("msg", "validation error"),
-                    }
-                )
-    return errors
-
-
-def _build_aggregated_schema() -> dict:
-    """Compose one JSON Schema per provider into a single top-level schema.
-
-    The output mirrors the layout of `prowler/config/config.yaml` (a mapping
-    keyed by provider type) and is what the UI consumes via `ajv`.
-    """
-    properties: dict[str, dict] = {}
-    for provider, schema_cls in SCHEMAS.items():
-        properties[provider] = schema_cls.model_json_schema()
-    return {
-        "$schema": "https://json-schema.org/draft/2020-12/schema",
-        "title": "Prowler Scan Config",
-        "type": "object",
-        "additionalProperties": True,
-        "properties": properties,
-    }
-
-
-SCAN_CONFIG_SCHEMA: dict = _build_aggregated_schema()

prowler/config/schema/aws.py

@@ -1,449 +0,0 @@
-"""AWS provider config schema.
-
-Bounds on every field are intentionally conservative: they are not the
-absolute service maxima but the values that produce a useful security
-check. A user is free to keep the built-in default by omitting the key —
-out-of-range values are dropped with a warning at SDK runtime, and
-rejected at the Prowler App backend.
-
-Whenever an upper bound is uncertain, the cap is set to a value that
-still keeps the check meaningful (e.g. a 10-year window for date-based
-thresholds) and avoids ints that obviously break downstream maths
-(`min_kinesis_stream_retention_hours = 99999`).
-"""
-
-from ipaddress import ip_network
-from typing import Annotated, Literal, Optional
-
-from pydantic import AfterValidator, Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-# ---- Reusable constants -----------------------------------------------------
-
-# CloudWatch Logs only accepts these retention values (in days). Anything else
-# is silently coerced to the next valid value by the API — we reject upfront.
-_CLOUDWATCH_RETENTION_DAYS = (
-    1,
-    3,
-    5,
-    7,
-    14,
-    30,
-    60,
-    90,
-    120,
-    150,
-    180,
-    365,
-    400,
-    545,
-    731,
-    1827,
-    2192,
-    2557,
-    2922,
-    3288,
-    3653,
-)
-
-_VALID_CW_RETENTION_LITERAL = Literal[
-    1,
-    3,
-    5,
-    7,
-    14,
-    30,
-    60,
-    90,
-    120,
-    150,
-    180,
-    365,
-    400,
-    545,
-    731,
-    1827,
-    2192,
-    2557,
-    2922,
-    3288,
-    3653,
-]
-
-
-# ---- Custom validators ------------------------------------------------------
-
-
-def _validate_port_range(v: Optional[list[int]]) -> Optional[list[int]]:
-    if v is None:
-        return v
-    for port in v:
-        if not 1 <= port <= 65535:
-            raise ValueError(f"port {port} is outside the valid range 1..65535")
-    return v
-
-
-def _validate_account_ids(v: Optional[list[str]]) -> Optional[list[str]]:
-    if v is None:
-        return v
-    for account_id in v:
-        if not (account_id.isdigit() and len(account_id) == 12):
-            raise ValueError(
-                f"trusted_account_ids entry {account_id!r} is not a 12-digit AWS account id"
-            )
-    return v
-
-
-def _validate_trusted_ips(v: Optional[list[str]]) -> Optional[list[str]]:
-    if v is None:
-        return v
-    for entry in v:
-        try:
-            ip_network(entry, strict=False)
-        except ValueError as exc:
-            raise ValueError(
-                f"trusted_ips entry {entry!r} is not a valid IP or CIDR ({exc})"
-            ) from exc
-    return v
-
-
-def _validate_semver(v: Optional[str]) -> Optional[str]:
-    """Accept "1.4.0" style strings (used by Fargate platform versions)."""
-    if v is None:
-        return v
-    parts = v.split(".")
-    if len(parts) != 3 or not all(p.isdigit() for p in parts):
-        raise ValueError(f"{v!r} is not a valid semantic version (expected X.Y.Z)")
-    return v
-
-
-def _validate_eks_minor(v: Optional[str]) -> Optional[str]:
-    """Accept "1.28" style strings (EKS minor versions)."""
-    if v is None:
-        return v
-    parts = v.split(".")
-    if len(parts) != 2 or not all(p.isdigit() for p in parts):
-        raise ValueError(f"{v!r} is not a valid EKS version (expected X.Y)")
-    return v
-
-
-# ---- Nested models ----------------------------------------------------------
-
-
-class _DetectSecretsPlugin(ProviderConfigBase):
-    """One entry inside ``detect_secrets_plugins``.
-
-    Only ``name`` is required by the upstream library. ``limit`` is used by
-    the entropy detectors. Any other plugin-specific kwarg is preserved by
-    the ``extra="allow"`` policy inherited from ProviderConfigBase.
-    """
-
-    name: str
-    limit: Optional[float] = Field(
-        default=None,
-        ge=0.0,
-        le=10.0,
-        description=(
-            "Entropy threshold for detect-secrets entropy plugins. Range: 0..10 "
-            "(Shannon entropy is bounded by log2(256)=8; >10 is meaningless)."
-        ),
-    )
-
-
-# ---- Main schema ------------------------------------------------------------
-
-
-class AWSProviderConfig(ProviderConfigBase):
-    # --- IAM ---------------------------------------------------------------
-    mute_non_default_regions: Optional[bool] = None
-    disallowed_regions: Optional[list[str]] = None
-    max_unused_access_keys_days: Optional[int] = Field(
-        default=None,
-        ge=30,
-        le=180,
-        description=(
-            "Days an IAM user access key can stay unused before being flagged. "
-            "Range: 30..180 days (CIS AWS 1.13 recommends 45; NIST IA-5 ≤90)."
-        ),
-    )
-    max_console_access_days: Optional[int] = Field(
-        default=None,
-        ge=30,
-        le=180,
-        description=(
-            "Days an IAM console password can stay unused before being flagged. "
-            "Range: 30..180 days (CIS AWS 1.12 recommends 45)."
-        ),
-    )
-    max_unused_sagemaker_access_days: Optional[int] = Field(
-        default=None,
-        ge=7,
-        le=180,
-        description=(
-            "Days a SageMaker user access key can stay unused. Range: 7..180 "
-            "(SageMaker tokens are usually high-privilege over S3/KMS)."
-        ),
-    )
-
-    # --- EC2 ---------------------------------------------------------------
-    shodan_api_key: Optional[str] = Field(
-        default=None,
-        max_length=512,
-        description="API key for Shodan lookups on EC2 public IPs.",
-    )
-    max_security_group_rules: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=1000,
-        description="Max ingress+egress rules per security group. AWS hard limit is 1000.",
-    )
-    max_ec2_instance_age_in_days: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=1095,
-        description=(
-            "Days an EC2 instance can run before being flagged as old. "
-            "Range: 1..1095 (3 years; instances should be refreshed for patching "
-            "per NIST CM-3 — anything older is a security smell)."
-        ),
-    )
-    ec2_allowed_interface_types: Optional[list[str]] = None
-    ec2_allowed_instance_owners: Optional[list[str]] = None
-    ec2_high_risk_ports: Annotated[
-        Optional[list[int]], AfterValidator(_validate_port_range)
-    ] = Field(
-        default=None,
-        description="TCP/UDP ports considered high-risk when reachable from the Internet (1..65535; port 0 is reserved).",
-    )
-
-    # --- ECS ---------------------------------------------------------------
-    fargate_linux_latest_version: Annotated[
-        Optional[str], AfterValidator(_validate_semver)
-    ] = Field(default=None, description="Fargate Linux platform version (X.Y.Z).")
-    fargate_windows_latest_version: Annotated[
-        Optional[str], AfterValidator(_validate_semver)
-    ] = Field(default=None, description="Fargate Windows platform version (X.Y.Z).")
-
-    # --- Cross-account trust ----------------------------------------------
-    trusted_account_ids: Annotated[
-        Optional[list[str]], AfterValidator(_validate_account_ids)
-    ] = Field(
-        default=None,
-        description="Additional 12-digit AWS account IDs trusted by cross-account checks.",
-    )
-    trusted_ips: Annotated[
-        Optional[list[str]], AfterValidator(_validate_trusted_ips)
-    ] = Field(
-        default=None,
-        description="IPv4/IPv6 addresses or CIDR ranges that are NOT considered public.",
-    )
-
-    # --- CloudWatch / CloudFormation --------------------------------------
-    log_group_retention_days: Optional[_VALID_CW_RETENTION_LITERAL] = Field(
-        default=None,
-        description=(
-            "Required CloudWatch Logs retention in days. Must match one of the "
-            f"values accepted by the AWS API: {list(_CLOUDWATCH_RETENTION_DAYS)}."
-        ),
-    )
-    recommended_cdk_bootstrap_version: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=100,
-        description="Min CDK bootstrap version expected on the account.",
-    )
-
-    # --- AppStream --------------------------------------------------------
-    max_idle_disconnect_timeout_in_seconds: Optional[int] = Field(
-        default=None,
-        ge=60,
-        le=1800,
-        description=(
-            "AppStream idle disconnect timeout (seconds). Range: 60..1800 "
-            "(NIST AC-12: sensitive sessions ≤15 min — cap at 30 min)."
-        ),
-    )
-    max_disconnect_timeout_in_seconds: Optional[int] = Field(
-        default=None,
-        ge=60,
-        le=3600,
-        description="AppStream disconnect timeout (seconds). Range: 60..3600.",
-    )
-    max_session_duration_seconds: Optional[int] = Field(
-        default=None,
-        ge=600,
-        le=86400,
-        description=(
-            "AppStream max session duration (seconds). Range: 600..86400 "
-            "(10 min .. 24 h — AWS AppStream hard limit per session)."
-        ),
-    )
-
-    # --- Lambda -----------------------------------------------------------
-    obsolete_lambda_runtimes: Optional[list[str]] = None
-    lambda_min_azs: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=6,
-        description="Min number of AZs a VPC-bound Lambda must span. Range: 1..6.",
-    )
-
-    # --- Organizations ----------------------------------------------------
-    organizations_enabled_regions: Optional[list[str]] = None
-    organizations_trusted_delegated_administrators: Annotated[
-        Optional[list[str]], AfterValidator(_validate_account_ids)
-    ] = None
-    organizations_trusted_ids: Optional[list[str]] = None
-
-    # --- ECR --------------------------------------------------------------
-    ecr_repository_vulnerability_minimum_severity: Optional[
-        Literal["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFORMATIONAL"]
-    ] = Field(
-        default=None,
-        description="Highest severity tolerated for ECR images.",
-    )
-
-    # --- Trusted Advisor --------------------------------------------------
-    verify_premium_support_plans: Optional[bool] = None
-
-    # --- CloudTrail threat detection: privilege escalation ----------------
-    threat_detection_privilege_escalation_threshold: Optional[float] = Field(
-        default=None,
-        ge=0.0,
-        le=1.0,
-        description="Fraction of suspicious actions that triggers the priv-esc detection.",
-    )
-    threat_detection_privilege_escalation_minutes: Optional[int] = Field(
-        default=None,
-        ge=5,
-        le=43200,
-        description=(
-            "Lookback window (minutes) for priv-esc detection. Range: 5..43200 "
-            "(under 5 min the signal is dominated by false positives)."
-        ),
-    )
-    threat_detection_privilege_escalation_actions: Optional[list[str]] = None
-
-    # --- CloudTrail threat detection: enumeration -------------------------
-    threat_detection_enumeration_threshold: Optional[float] = Field(
-        default=None,
-        ge=0.0,
-        le=1.0,
-        description="Fraction of suspicious actions that triggers the enumeration detection.",
-    )
-    threat_detection_enumeration_minutes: Optional[int] = Field(
-        default=None,
-        ge=5,
-        le=43200,
-        description="Lookback window (minutes) for enumeration detection. Range: 5..43200.",
-    )
-    threat_detection_enumeration_actions: Optional[list[str]] = None
-
-    # --- CloudTrail threat detection: LLM jacking -------------------------
-    threat_detection_llm_jacking_threshold: Optional[float] = Field(
-        default=None,
-        ge=0.0,
-        le=1.0,
-        description="Fraction of suspicious actions that triggers the LLM-jacking detection.",
-    )
-    threat_detection_llm_jacking_minutes: Optional[int] = Field(
-        default=None,
-        ge=5,
-        le=43200,
-        description="Lookback window (minutes) for LLM-jacking detection. Range: 5..43200.",
-    )
-    threat_detection_llm_jacking_actions: Optional[list[str]] = None
-
-    # --- RDS --------------------------------------------------------------
-    check_rds_instance_replicas: Optional[bool] = None
-
-    # --- ACM --------------------------------------------------------------
-    days_to_expire_threshold: Optional[int] = Field(
-        default=None,
-        ge=7,
-        le=365,
-        description=(
-            "Days before certificate expiration to flag. Range: 7..365 "
-            "(PCI-DSS 4.2.1.1: alert ≥30 days before expiry; <7 days is too "
-            "tight to actually act on)."
-        ),
-    )
-    insecure_key_algorithms: Optional[list[str]] = None
-
-    # --- EKS --------------------------------------------------------------
-    eks_required_log_types: Optional[
-        list[
-            Literal[
-                "api",
-                "audit",
-                "authenticator",
-                "controllerManager",
-                "scheduler",
-            ]
-        ]
-    ] = Field(
-        default=None,
-        description="EKS control plane log types that must be enabled.",
-    )
-    eks_cluster_oldest_version_supported: Annotated[
-        Optional[str], AfterValidator(_validate_eks_minor)
-    ] = Field(
-        default=None,
-        description='Minimum supported EKS minor version, expected as "X.Y".',
-    )
-
-    # --- CodeBuild --------------------------------------------------------
-    excluded_sensitive_environment_variables: Optional[list[str]] = None
-    codebuild_github_allowed_organizations: Optional[list[str]] = None
-
-    # --- ELB / ELBv2 ------------------------------------------------------
-    elb_min_azs: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=6,
-        description="Min AZs a Classic ELB must span. Range: 1..6.",
-    )
-    elbv2_min_azs: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=6,
-        description="Min AZs an Application/Network LB must span. Range: 1..6.",
-    )
-
-    # --- ElastiCache -----------------------------------------------------
-    minimum_snapshot_retention_period: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=35,
-        description="Days an ElastiCache backup must be retained. Range: 1..35 (service hard limit).",
-    )
-
-    # --- Secrets ---------------------------------------------------------
-    secrets_ignore_patterns: Optional[list[str]] = None
-    max_days_secret_unused: Optional[int] = Field(
-        default=None,
-        ge=7,
-        le=365,
-        description="Days a Secrets Manager secret can stay unused. Range: 7..365.",
-    )
-    max_days_secret_unrotated: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=180,
-        description=(
-            "Days a Secrets Manager secret can go without rotation. Range: 1..180 "
-            "(NIST IA-5: rotate quarterly; CIS recommends ≤90)."
-        ),
-    )
-
-    # --- Kinesis ---------------------------------------------------------
-    min_kinesis_stream_retention_hours: Optional[int] = Field(
-        default=None,
-        ge=24,
-        le=8760,
-        description="Hours of Kinesis stream retention. Range: 24..8760 (1 day .. 1 year).",
-    )
-
-    # --- detect-secrets plugin list -------------------------------------
-    detect_secrets_plugins: Optional[list[_DetectSecretsPlugin]] = None

prowler/config/schema/azure.py

@@ -1,91 +0,0 @@
-"""Azure provider config schema with safety bounds.
-
-Bounds aim for values that produce a meaningful security check; out-of-range
-values are dropped (SDK runtime) or rejected (Prowler App backend).
-"""
-
-from typing import Annotated, Literal, Optional
-
-from pydantic import AfterValidator, Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-def _validate_dotted_version(v: Optional[str]) -> Optional[str]:
-    """Accept ``"8.2"``, ``"3.12"``, ``"17"`` style version strings.
-
-    Used by App Service language version fields where the upstream APIs
-    accept either ``MAJOR`` or ``MAJOR.MINOR`` notation.
-    """
-    if v is None:
-        return v
-    parts = v.split(".")
-    if not (1 <= len(parts) <= 2) or not all(p.isdigit() for p in parts):
-        raise ValueError(f"{v!r} is not a valid version (expected 'X' or 'X.Y')")
-    return v
-
-
-class AzureProviderConfig(ProviderConfigBase):
-    # --- Network ---------------------------------------------------------
-    shodan_api_key: Optional[str] = Field(
-        default=None,
-        max_length=512,
-        description="API key for Shodan lookups on Azure public IPs.",
-    )
-
-    # --- Defender --------------------------------------------------------
-    defender_attack_path_minimal_risk_level: Optional[
-        Literal["Low", "Medium", "High", "Critical"]
-    ] = Field(
-        default=None,
-        description="Minimum attack-path risk level worth a notification.",
-    )
-
-    # --- App Service ----------------------------------------------------
-    php_latest_version: Annotated[
-        Optional[str], AfterValidator(_validate_dotted_version)
-    ] = Field(default=None, description='PHP minimum acceptable version, e.g. "8.2".')
-    python_latest_version: Annotated[
-        Optional[str], AfterValidator(_validate_dotted_version)
-    ] = Field(
-        default=None, description='Python minimum acceptable version, e.g. "3.12".'
-    )
-    java_latest_version: Annotated[
-        Optional[str], AfterValidator(_validate_dotted_version)
-    ] = Field(default=None, description='Java minimum acceptable version, e.g. "17".')
-
-    # --- SQL ------------------------------------------------------------
-    recommended_minimal_tls_versions: Optional[list[Literal["1.2", "1.3"]]] = Field(
-        default=None,
-        description="TLS versions accepted on Azure SQL Server.",
-    )
-
-    # --- Virtual Machines -----------------------------------------------
-    desired_vm_sku_sizes: Optional[list[str]] = None
-    vm_backup_min_daily_retention_days: Optional[int] = Field(
-        default=None,
-        ge=7,
-        le=9999,
-        description=(
-            "Min daily backup retention days. Range: 7..9999 "
-            "(Azure Backup hard limit; <7 days defeats DR/ransomware recovery)."
-        ),
-    )
-
-    # --- API Management threat detection (LLM jacking) -----------------
-    apim_threat_detection_llm_jacking_threshold: Optional[float] = Field(
-        default=None,
-        ge=0.0,
-        le=1.0,
-        description="Fraction of suspicious actions that triggers the detection.",
-    )
-    apim_threat_detection_llm_jacking_minutes: Optional[int] = Field(
-        default=None,
-        ge=5,
-        le=43200,
-        description=(
-            "Lookback window (minutes) for LLM-jacking detection. Range: 5..43200 "
-            "(under 5 min the signal is dominated by false positives)."
-        ),
-    )
-    apim_threat_detection_llm_jacking_actions: Optional[list[str]] = None

prowler/config/schema/base.py

@@ -1,17 +0,0 @@
-from pydantic import BaseModel, ConfigDict
-
-
-class ProviderConfigBase(BaseModel):
-    """Base for every provider config schema.
-
-    ``extra="allow"`` is REQUIRED for backwards compatibility: third-party
-    check plugins frequently introduce config keys we do not know about,
-    and pre-existing user configs may carry deprecated keys. Validation
-    must never reject these.
-    """
-
-    model_config = ConfigDict(
-        extra="allow",
-        str_strip_whitespace=True,
-        validate_assignment=False,
-    )

prowler/config/schema/cloudflare.py

@@ -1,18 +0,0 @@
-"""Cloudflare provider config schema with safety bounds."""
-
-from typing import Optional
-
-from pydantic import Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-class CloudflareProviderConfig(ProviderConfigBase):
-    max_retries: Optional[int] = Field(
-        default=None,
-        ge=0,
-        le=10,
-        description=(
-            "Max retries for Cloudflare API requests. Range: 0..10 (0 disables retries)."
-        ),
-    )

prowler/config/schema/gcp.py

@@ -1,45 +0,0 @@
-"""GCP provider config schema with safety bounds."""
-
-from typing import Optional
-
-from pydantic import Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-class GCPProviderConfig(ProviderConfigBase):
-    shodan_api_key: Optional[str] = Field(
-        default=None,
-        max_length=512,
-        description="API key for Shodan lookups on GCP public IPs.",
-    )
-    mig_min_zones: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=5,
-        description="Min zones a Managed Instance Group must span. Range: 1..5.",
-    )
-    max_snapshot_age_days: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=1095,
-        description=(
-            "Days a disk snapshot can age before being flagged. Range: 1..1095 "
-            "(3 years; older snapshots typically miss data-class compliance)."
-        ),
-    )
-    max_unused_account_days: Optional[int] = Field(
-        default=None,
-        ge=30,
-        le=365,
-        description=(
-            "Days a service account or user-managed key can stay unused. "
-            "Range: 30..365."
-        ),
-    )
-    storage_min_retention_days: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=3650,
-        description="Min retention period on Cloud Storage buckets. Range: 1..3650.",
-    )

prowler/config/schema/github.py

@@ -1,20 +0,0 @@
-"""GitHub provider config schema with safety bounds."""
-
-from typing import Optional
-
-from pydantic import Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-class GitHubProviderConfig(ProviderConfigBase):
-    inactive_not_archived_days_threshold: Optional[int] = Field(
-        default=None,
-        ge=30,
-        le=3650,
-        description=(
-            "Days a repository can stay inactive without being archived before "
-            "being flagged. Range: 30..3650 (CIS GitHub recommends 180; "
-            "<30 days produces false positives on seasonal projects)."
-        ),
-    )

prowler/config/schema/kubernetes.py

@@ -1,45 +0,0 @@
-"""Kubernetes provider config schema with safety bounds."""
-
-from typing import Optional
-
-from pydantic import Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-class KubernetesProviderConfig(ProviderConfigBase):
-    audit_log_maxbackup: Optional[int] = Field(
-        default=None,
-        ge=2,
-        le=1000,
-        description=(
-            "API server audit log file rotations to keep. Range: 2..1000 "
-            "(CIS Kubernetes 1.2.18 recommends ≥10)."
-        ),
-    )
-    audit_log_maxsize: Optional[int] = Field(
-        default=None,
-        ge=10,
-        le=10000,
-        description=(
-            "Max MB per audit log file before rotation. Range: 10..10000 MB "
-            "(CIS Kubernetes 1.2.19 recommends ≥100 MB)."
-        ),
-    )
-    audit_log_maxage: Optional[int] = Field(
-        default=None,
-        ge=7,
-        le=3650,
-        description=(
-            "Days an audit log file is retained. Range: 7..3650 "
-            "(CIS Kubernetes 1.2.17 recommends ≥30 days)."
-        ),
-    )
-    apiserver_strong_ciphers: Optional[list[str]] = Field(
-        default=None,
-        description="Whitelist of strong TLS cipher suites required on the API server.",
-    )
-    kubelet_strong_ciphers: Optional[list[str]] = Field(
-        default=None,
-        description="Whitelist of strong TLS cipher suites required on kubelet.",
-    )

prowler/config/schema/m365.py

@@ -1,54 +0,0 @@
-"""M365 provider config schema with safety bounds."""
-
-from typing import Optional
-
-from pydantic import Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-class M365ProviderConfig(ProviderConfigBase):
-    # --- Entra (sign-in policy) ----------------------------------------
-    sign_in_frequency: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=168,
-        description=(
-            "Hours between forced sign-ins for admin users. Range: 1..168 (1 h .. 7 days). "
-            "Microsoft Conditional Access baseline for admin roles is ≤24 h."
-        ),
-    )
-
-    # --- Teams ---------------------------------------------------------
-    allowed_cloud_storage_services: Optional[list[str]] = Field(
-        default=None,
-        description="External cloud storage services allowed in Teams.",
-    )
-
-    # --- Exchange ------------------------------------------------------
-    recommended_mailtips_large_audience_threshold: Optional[int] = Field(
-        default=None,
-        ge=5,
-        le=10000,
-        description=(
-            "Recipient count that should trigger a 'large audience' MailTip. "
-            "Range: 5..10000 (Microsoft default 25)."
-        ),
-    )
-
-    # --- Defender malware policy --------------------------------------
-    default_recommended_extensions: Optional[list[str]] = Field(
-        default=None,
-        description="File extensions blocked by the malware policy.",
-    )
-
-    # --- Mailbox auditing ---------------------------------------------
-    audit_log_age: Optional[int] = Field(
-        default=None,
-        ge=30,
-        le=3650,
-        description=(
-            "Days mailbox audit logs must be retained. Range: 30..3650 "
-            "(M365 E3 default is 90 days; SEC/FINRA require ≥7 years)."
-        ),
-    )

prowler/config/schema/mongodbatlas.py

@@ -1,19 +0,0 @@
-"""MongoDB Atlas provider config schema with safety bounds."""
-
-from typing import Optional
-
-from pydantic import Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-class MongoDBAtlasProviderConfig(ProviderConfigBase):
-    max_service_account_secret_validity_hours: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=720,
-        description=(
-            "Max hours a service account secret can stay valid. "
-            "Range: 1..720 (1 h .. 30 days)."
-        ),
-    )

prowler/config/schema/registry.py

@@ -1,28 +0,0 @@
-"""Mapping of provider name to its Pydantic schema class.
-
-Kept in its own module so the validator stays free of provider-schema imports
-and callers pay the import cost only when they actually need the registry.
-"""
-
-from prowler.config.schema.aws import AWSProviderConfig
-from prowler.config.schema.azure import AzureProviderConfig
-from prowler.config.schema.base import ProviderConfigBase
-from prowler.config.schema.cloudflare import CloudflareProviderConfig
-from prowler.config.schema.gcp import GCPProviderConfig
-from prowler.config.schema.github import GitHubProviderConfig
-from prowler.config.schema.kubernetes import KubernetesProviderConfig
-from prowler.config.schema.m365 import M365ProviderConfig
-from prowler.config.schema.mongodbatlas import MongoDBAtlasProviderConfig
-from prowler.config.schema.vercel import VercelProviderConfig
-
-SCHEMAS: dict[str, type[ProviderConfigBase]] = {
-    "aws": AWSProviderConfig,
-    "azure": AzureProviderConfig,
-    "gcp": GCPProviderConfig,
-    "kubernetes": KubernetesProviderConfig,
-    "m365": M365ProviderConfig,
-    "github": GitHubProviderConfig,
-    "mongodbatlas": MongoDBAtlasProviderConfig,
-    "cloudflare": CloudflareProviderConfig,
-    "vercel": VercelProviderConfig,
-}

prowler/config/schema/validator.py

@@ -1,61 +0,0 @@
-from typing import Any
-
-from pydantic import ValidationError
-
-from prowler.config.schema.base import ProviderConfigBase
-from prowler.lib.logger import logger
-
-
-def validate_provider_config(
-    provider: str,
-    raw: Any,
-    schema_cls: type[ProviderConfigBase] | None,
-) -> dict:
-    """Validate a provider's config dict against its Pydantic schema.
-
-    Behavior is intentionally lenient to preserve backwards compatibility:
-
-    - If ``raw`` is not a dict, return an empty dict (mirrors prior loader).
-    - If no schema is registered for ``provider``, return ``raw`` untouched.
-    - On validation errors, log one WARNING per offending field, DROP those
-      keys from the result, and continue. Consumers fall back to their own
-      hard-coded defaults via ``audit_config.get(key, default)``.
-    - Coerced values (e.g. ``"180"`` -> ``180``) replace the user's input
-      so that downstream checks never receive a wrongly-typed value.
-    """
-    if not isinstance(raw, dict):
-        return {}
-
-    if schema_cls is None:
-        return raw
-
-    try:
-        model = schema_cls.model_validate(raw)
-        return model.model_dump(exclude_unset=True)
-    except ValidationError as exc:
-        bad_keys: set[str] = set()
-        for err in exc.errors():
-            loc = err.get("loc") or ()
-            if not loc:
-                continue
-            key = loc[0]
-            if not isinstance(key, str):
-                continue
-            bad_keys.add(key)
-            logger.warning(
-                f"prowler.config[{provider}.{key}] = {raw.get(key)!r} is invalid "
-                f"({err.get('msg', 'validation error')}); the value will be ignored "
-                f"and the built-in default will be used."
-            )
-
-        cleaned = {k: v for k, v in raw.items() if k not in bad_keys}
-        try:
-            model = schema_cls.model_validate(cleaned)
-            return model.model_dump(exclude_unset=True)
-        except ValidationError as exc2:
-            logger.error(
-                f"prowler.config[{provider}] could not be revalidated after dropping "
-                f"invalid keys ({bad_keys}); passing through the cleaned dict as-is. "
-                f"Underlying errors: {exc2.errors()}"
-            )
-            return cleaned

prowler/config/schema/vercel.py

@@ -1,61 +0,0 @@
-"""Vercel provider config schema with safety bounds."""
-
-from typing import Optional
-
-from pydantic import Field
-
-from prowler.config.schema.base import ProviderConfigBase
-
-
-class VercelProviderConfig(ProviderConfigBase):
-    stable_branches: Optional[list[str]] = Field(
-        default=None,
-        description="Branches considered stable for production deployments.",
-    )
-    days_to_expire_threshold: Optional[int] = Field(
-        default=None,
-        ge=7,
-        le=365,
-        description=(
-            "Days before token/certificate expiration to flag. Range: 7..365 "
-            "(PCI-DSS 4.2.1.1: alert ≥30 days before expiry)."
-        ),
-    )
-    stale_token_threshold_days: Optional[int] = Field(
-        default=None,
-        ge=30,
-        le=3650,
-        description=(
-            "Days of inactivity before a token is considered stale. Range: 30..3650 "
-            "(NIST AC-2(3) typical window 30..90 days)."
-        ),
-    )
-    stale_invitation_threshold_days: Optional[int] = Field(
-        default=None,
-        ge=7,
-        le=365,
-        description=(
-            "Days a pending invitation can stay open. Range: 7..365 "
-            "(OWASP ASVS 2.7.1 recommends short-lived invitations)."
-        ),
-    )
-    max_owner_percentage: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=50,
-        description=(
-            "Max percentage of team members that can have the OWNER role. "
-            "Range: 1..50 (PoLP — having >50% of a team as OWNER defeats RBAC; "
-            "industry guidance recommends ≤25%)."
-        ),
-    )
-    max_owners: Optional[int] = Field(
-        default=None,
-        ge=1,
-        le=1000,
-        description="Absolute max owners (overrides percentage for large teams). Range: 1..1000.",
-    )
-    secret_suffixes: Optional[list[str]] = Field(
-        default=None,
-        description="Suffixes that mark a project env var as secret-like.",
-    )

prowler/lib/banner.py

@@ -3,12 +3,13 @@ from colorama import Fore, Style
 from prowler.config.config import banner_color, orange_color, prowler_version, timestamp
 
 
-def print_banner(legend: bool = False):
+def print_banner(legend: bool = False, provider: str = None):
     """
     Prints the banner with optional legend for color codes.
 
     Parameters:
     - legend (bool): Flag to indicate whether to print the color legend or not. Default is False.
+    - provider (str): The provider being scanned, used to tailor the Prowler Cloud banner.
 
     Returns:
     - None
@@ -20,13 +21,12 @@ def print_banner(legend: bool = False):
 | .__/|_|  \___/ \_/\_/ |_|\___|_|v{prowler_version}
 |_|{Fore.BLUE} Get the most at https://cloud.prowler.com {Style.RESET_ALL}
 
-{Fore.GREEN}New! Send findings from Prowler CLI to Prowler Cloud{Style.RESET_ALL}
-{Fore.GREEN}More details here: goto.prowler.com/import-findings{Style.RESET_ALL}
-
 {Fore.YELLOW}Date: {timestamp.strftime("%Y-%m-%d %H:%M:%S")}{Style.RESET_ALL}
 """
     print(banner)
 
+    print_prowler_cloud_banner(provider)
+
     if legend:
         print(
             f"""
@@ -37,3 +37,37 @@ def print_banner(legend: bool = False):
 - {Fore.RED}FAIL (Fix required){Style.RESET_ALL}
             """
         )
+
+
+def print_prowler_cloud_banner(provider: str = None):
+    """
+    Prints a promotional banner highlighting what Prowler Cloud adds on top of
+    the open-source CLI.
+
+    Shown at the start and end of a scan to let users know about the managed
+    platform capabilities they are missing (attack paths, AI, organizations,
+    continuous scanning, integrations and live compliance dashboards).
+
+    Parameters:
+    - provider (str): The provider that was scanned, used to tailor the message.
+
+    Returns:
+    - None
+    """
+    check = f"{Fore.GREEN}✓{Style.RESET_ALL}"
+    bar = f"{banner_color}│{Style.RESET_ALL}"
+    print(
+        f"""
+{bar} {Style.BRIGHT}You're getting a snapshot. Prowler Cloud gives you the full picture.{Style.RESET_ALL}
+{bar}
+{bar} {check} {Style.BRIGHT}Attack Path Visualization{Style.RESET_ALL} - see how attackers chain risks to reach your crown jewels
+{bar} {check} {Style.BRIGHT}Lighthouse AI + MCP{Style.RESET_ALL} - autonomous triage, prioritization and remediation
+{bar} {check} {Style.BRIGHT}Organizations{Style.RESET_ALL} - all your AWS accounts under one organization
+{bar} {check} {Style.BRIGHT}Continuous scanning{Style.RESET_ALL} - scheduled scans with history, trends and alerts
+{bar} {check} {Style.BRIGHT}Integrations{Style.RESET_ALL} - Jira, Slack, AWS Security Hub, Amazon S3, SSO and RBAC
+{bar} {check} {Style.BRIGHT}Reports{Style.RESET_ALL} - download ready-to-share PDF reports
+{bar} {check} {Style.BRIGHT}Live compliance{Style.RESET_ALL} - dashboards for 50+ frameworks, always up to date
+{bar}
+{bar} {Fore.BLUE}Start free at cloud.prowler.com{Style.RESET_ALL}
+"""
+    )

prowler/lib/check/compliance_models.py

@@ -283,6 +283,26 @@ class CSA_CCM_Requirement_Attribute(BaseModel):
     ScopeApplicability: list[dict]
 
 
+class STIG_Requirement_Attribute_Severity(str, Enum):
+    """DISA STIG Requirement Attribute Severity (maps to CAT I/II/III)"""
+
+    high = "high"
+    medium = "medium"
+    low = "low"
+
+
+class STIG_Requirement_Attribute(BaseModel):
+    """DISA STIG Requirement Attribute"""
+
+    Section: str
+    Severity: STIG_Requirement_Attribute_Severity
+    RuleID: str
+    StigID: str
+    CCI: Optional[list[str]] = None
+    CheckText: Optional[str] = None
+    FixText: Optional[str] = None
+
+
 # Base Compliance Model
 # TODO: move this to compliance folder
 class Compliance_Requirement(BaseModel):
@@ -303,6 +323,7 @@ class Compliance_Requirement(BaseModel):
             CCC_Requirement_Attribute,
             C5Germany_Requirement_Attribute,
             CSA_CCM_Requirement_Attribute,
+            STIG_Requirement_Attribute,
             # Generic_Compliance_Requirement_Attribute must be the last one since it is the fallback for generic compliance framework
             Generic_Compliance_Requirement_Attribute,
         ]

prowler/lib/outputs/compliance/compliance.py

@@ -18,6 +18,9 @@ from prowler.lib.outputs.compliance.kisa_ismsp.kisa_ismsp import get_kisa_ismsp_
 from prowler.lib.outputs.compliance.mitre_attack.mitre_attack import (
     get_mitre_attack_table,
 )
+from prowler.lib.outputs.compliance.okta_idaas_stig.okta_idaas_stig import (
+    get_okta_idaas_stig_table,
+)
 from prowler.lib.outputs.compliance.prowler_threatscore.prowler_threatscore import (
     get_prowler_threatscore_table,
 )
@@ -252,6 +255,15 @@ def display_compliance_table(
                 output_directory,
                 compliance_overview,
             )
+        elif compliance_framework.startswith("okta_idaas_stig"):
+            get_okta_idaas_stig_table(
+                findings,
+                bulk_checks_metadata,
+                compliance_framework,
+                output_filename,
+                output_directory,
+                compliance_overview,
+            )
         else:
             # Try provider-specific table first, fall back to generic
             from prowler.providers.common.provider import Provider

prowler/lib/outputs/compliance/okta_idaas_stig/models.py

@@ -0,0 +1,32 @@
+from typing import Optional
+
+from pydantic.v1 import BaseModel
+
+
+class OktaIDaaSSTIGModel(BaseModel):
+    """
+    OktaIDaaSSTIGModel generates a finding's output in DISA Okta IDaaS STIG Compliance format.
+    """
+
+    Provider: str
+    Description: str
+    OrganizationDomain: str
+    AssessmentDate: str
+    Requirements_Id: str
+    Requirements_Name: str
+    Requirements_Description: str
+    Requirements_Attributes_Section: str
+    Requirements_Attributes_Severity: str
+    Requirements_Attributes_RuleID: str
+    Requirements_Attributes_StigID: str
+    Requirements_Attributes_CCI: Optional[list[str]] = None
+    Requirements_Attributes_CheckText: Optional[str] = None
+    Requirements_Attributes_FixText: Optional[str] = None
+    Status: str
+    StatusExtended: str
+    ResourceId: str
+    ResourceName: str
+    CheckId: str
+    Muted: bool
+    Framework: str
+    Name: str

prowler/lib/outputs/compliance/okta_idaas_stig/okta_idaas_stig.py

@@ -0,0 +1,98 @@
+from colorama import Fore, Style
+from tabulate import tabulate
+
+from prowler.config.config import orange_color
+
+
+def get_okta_idaas_stig_table(
+    findings: list,
+    bulk_checks_metadata: dict,
+    compliance_framework: str,
+    output_filename: str,
+    output_directory: str,
+    compliance_overview: bool,
+):
+    section_table = {
+        "Provider": [],
+        "Section": [],
+        "Status": [],
+        "Muted": [],
+    }
+    pass_count = []
+    fail_count = []
+    muted_count = []
+    sections = {}
+    for index, finding in enumerate(findings):
+        check = bulk_checks_metadata[finding.check_metadata.CheckID]
+        check_compliances = check.Compliance
+        for compliance in check_compliances:
+            if compliance.Framework == "Okta-IDaaS-STIG":
+                for requirement in compliance.Requirements:
+                    for attribute in requirement.Attributes:
+                        section = attribute.Section
+
+                        if section not in sections:
+                            sections[section] = {"FAIL": 0, "PASS": 0, "Muted": 0}
+
+                        if finding.muted:
+                            if index not in muted_count:
+                                muted_count.append(index)
+                                sections[section]["Muted"] += 1
+                        else:
+                            if finding.status == "FAIL" and index not in fail_count:
+                                fail_count.append(index)
+                                sections[section]["FAIL"] += 1
+                            elif finding.status == "PASS" and index not in pass_count:
+                                pass_count.append(index)
+                                sections[section]["PASS"] += 1
+
+    sections = dict(sorted(sections.items()))
+    for section in sections:
+        section_table["Provider"].append(compliance.Provider)
+        section_table["Section"].append(section)
+        if sections[section]["FAIL"] > 0:
+            section_table["Status"].append(
+                f"{Fore.RED}FAIL({sections[section]['FAIL']}){Style.RESET_ALL}"
+            )
+        else:
+            if sections[section]["PASS"] > 0:
+                section_table["Status"].append(
+                    f"{Fore.GREEN}PASS({sections[section]['PASS']}){Style.RESET_ALL}"
+                )
+            else:
+                section_table["Status"].append(f"{Fore.GREEN}PASS{Style.RESET_ALL}")
+        section_table["Muted"].append(
+            f"{orange_color}{sections[section]['Muted']}{Style.RESET_ALL}"
+        )
+
+    if (
+        len(fail_count) + len(pass_count) + len(muted_count) > 1
+    ):  # If there are no resources, don't print the compliance table
+        print(
+            f"\nCompliance Status of {Fore.YELLOW}{compliance_framework.upper()}{Style.RESET_ALL} Framework:"
+        )
+        total_findings_count = len(fail_count) + len(pass_count) + len(muted_count)
+        overview_table = [
+            [
+                f"{Fore.RED}{round(len(fail_count) / total_findings_count * 100, 2)}% ({len(fail_count)}) FAIL{Style.RESET_ALL}",
+                f"{Fore.GREEN}{round(len(pass_count) / total_findings_count * 100, 2)}% ({len(pass_count)}) PASS{Style.RESET_ALL}",
+                f"{orange_color}{round(len(muted_count) / total_findings_count * 100, 2)}% ({len(muted_count)}) MUTED{Style.RESET_ALL}",
+            ]
+        ]
+        print(tabulate(overview_table, tablefmt="rounded_grid"))
+        if not compliance_overview:
+            if len(fail_count) > 0 and len(section_table["Section"]) > 0:
+                print(
+                    f"\nFramework {Fore.YELLOW}{compliance_framework.upper()}{Style.RESET_ALL} Results:"
+                )
+                print(
+                    tabulate(
+                        section_table,
+                        tablefmt="rounded_grid",
+                        headers="keys",
+                    )
+                )
+                print(f"\nDetailed results of {compliance_framework.upper()} are in:")
+                print(
+                    f" - CSV: {output_directory}/compliance/{output_filename}_{compliance_framework}.csv\n"
+                )

prowler/lib/outputs/compliance/okta_idaas_stig/okta_idaas_stig_okta.py

@@ -0,0 +1,95 @@
+from prowler.config.config import timestamp
+from prowler.lib.check.compliance_models import Compliance
+from prowler.lib.outputs.compliance.compliance_output import ComplianceOutput
+from prowler.lib.outputs.compliance.okta_idaas_stig.models import OktaIDaaSSTIGModel
+from prowler.lib.outputs.finding import Finding
+
+
+class OktaIDaaSSTIG(ComplianceOutput):
+    """
+    This class represents the Okta IDaaS STIG compliance output.
+
+    Attributes:
+        - _data (list): A list to store transformed data from findings.
+        - _file_descriptor (TextIOWrapper): A file descriptor to write data to a file.
+
+    Methods:
+        - transform: Transforms findings into Okta IDaaS STIG compliance format.
+    """
+
+    def transform(
+        self,
+        findings: list[Finding],
+        compliance: Compliance,
+        _compliance_name: str,
+    ) -> None:
+        """
+        Transforms a list of findings into Okta IDaaS STIG compliance format.
+
+        Parameters:
+            - findings (list): A list of findings.
+            - compliance (Compliance): A compliance model.
+            - _compliance_name (str): The name of the compliance model (unused).
+
+        Returns:
+            - None
+        """
+        for finding in findings:
+            for requirement in compliance.Requirements:
+                # Source of truth: framework JSON, not finding.compliance snapshot (avoids CSV/UI count drift).
+                if finding.check_id in requirement.Checks:
+                    for attribute in requirement.Attributes:
+                        compliance_row = OktaIDaaSSTIGModel(
+                            Provider=finding.provider,
+                            Description=compliance.Description,
+                            OrganizationDomain=finding.account_name,
+                            AssessmentDate=str(timestamp),
+                            Requirements_Id=requirement.Id,
+                            Requirements_Name=requirement.Name,
+                            Requirements_Description=requirement.Description,
+                            Requirements_Attributes_Section=attribute.Section,
+                            Requirements_Attributes_Severity=attribute.Severity.value,
+                            Requirements_Attributes_RuleID=attribute.RuleID,
+                            Requirements_Attributes_StigID=attribute.StigID,
+                            Requirements_Attributes_CCI=attribute.CCI,
+                            Requirements_Attributes_CheckText=attribute.CheckText,
+                            Requirements_Attributes_FixText=attribute.FixText,
+                            Status=finding.status,
+                            StatusExtended=finding.status_extended,
+                            ResourceId=finding.resource_uid,
+                            ResourceName=finding.resource_name,
+                            CheckId=finding.check_id,
+                            Muted=finding.muted,
+                            Framework=compliance.Framework,
+                            Name=compliance.Name,
+                        )
+                        self._data.append(compliance_row)
+        # Add manual requirements to the compliance output
+        for requirement in compliance.Requirements:
+            if not requirement.Checks:
+                for attribute in requirement.Attributes:
+                    compliance_row = OktaIDaaSSTIGModel(
+                        Provider=compliance.Provider.lower(),
+                        Description=compliance.Description,
+                        OrganizationDomain="",
+                        AssessmentDate=str(timestamp),
+                        Requirements_Id=requirement.Id,
+                        Requirements_Name=requirement.Name,
+                        Requirements_Description=requirement.Description,
+                        Requirements_Attributes_Section=attribute.Section,
+                        Requirements_Attributes_Severity=attribute.Severity.value,
+                        Requirements_Attributes_RuleID=attribute.RuleID,
+                        Requirements_Attributes_StigID=attribute.StigID,
+                        Requirements_Attributes_CCI=attribute.CCI,
+                        Requirements_Attributes_CheckText=attribute.CheckText,
+                        Requirements_Attributes_FixText=attribute.FixText,
+                        Status="MANUAL",
+                        StatusExtended="Manual check",
+                        ResourceId="manual_check",
+                        ResourceName="Manual check",
+                        CheckId="manual",
+                        Muted=False,
+                        Framework=compliance.Framework,
+                        Name=compliance.Name,
+                    )
+                    self._data.append(compliance_row)

prowler/providers/aws/services/bedrock/bedrock_agent_role_least_privilege/bedrock_agent_role_least_privilege.metadata.json

@@ -0,0 +1,41 @@
+{
+  "Provider": "aws",
+  "CheckID": "bedrock_agent_role_least_privilege",
+  "CheckTitle": "Amazon Bedrock agent execution role follows least privilege",
+  "CheckType": [
+    "Software and Configuration Checks/AWS Security Best Practices/Runtime Behavior Analysis",
+    "TTPs/Privilege Escalation"
+  ],
+  "ServiceName": "bedrock",
+  "SubServiceName": "",
+  "ResourceIdTemplate": "",
+  "Severity": "high",
+  "ResourceType": "Other",
+  "ResourceGroup": "ai_ml",
+  "Description": "**Bedrock Agent** execution roles (`agentResourceRoleArn`) should grant only the minimum permissions the agent needs. The evaluation FAILs when the role has an AWS-managed `*FullAccess` policy attached, has an inline statement allowing broad actions on `Resource: \"*\"`, or has no permissions boundary configured.",
+  "Risk": "An overly permissive **Bedrock Agent** execution role turns a successful **prompt injection** into AWS privilege escalation. A model coerced into calling tools can invoke any API the role allows — reading secrets, modifying IAM, exfiltrating data from S3, or pivoting laterally. **Least privilege** plus a **permissions boundary** keeps the blast radius bounded even when guardrails fail.",
+  "RelatedUrl": "",
+  "AdditionalURLs": [
+    "https://docs.aws.amazon.com/bedrock/latest/userguide/agents-permissions.html",
+    "https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html",
+    "https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege"
+  ],
+  "Remediation": {
+    "Code": {
+      "CLI": "aws iam put-role-permissions-boundary --role-name <execution_role_name> --permissions-boundary <boundary_policy_arn>",
+      "NativeIaC": "",
+      "Other": "1. Identify the Bedrock Agent's execution role (agentResourceRoleArn) in the IAM console\n2. Detach any AWS-managed *FullAccess policies (e.g. AmazonBedrockFullAccess, AdministratorAccess)\n3. Replace inline policies that use Resource: \"*\" with statements scoped to specific resource ARNs and minimal action sets\n4. Attach a permissions boundary that caps what the role can ever do, even if a future policy is added\n5. Re-run Prowler to confirm the check passes",
+      "Terraform": "```hcl\nresource \"aws_iam_role\" \"bedrock_agent\" {\n  name                 = \"<execution_role_name>\"\n  assume_role_policy   = data.aws_iam_policy_document.trust.json\n  permissions_boundary = aws_iam_policy.bedrock_agent_boundary.arn  # CRITICAL: caps maximum privileges\n}\n\nresource \"aws_iam_role_policy\" \"bedrock_agent_inline\" {\n  role   = aws_iam_role.bedrock_agent.name\n  policy = jsonencode({\n    Version = \"2012-10-17\",\n    Statement = [{\n      Effect   = \"Allow\",\n      Action   = [\"s3:GetObject\"],            # CRITICAL: narrow action\n      Resource = [\"arn:aws:s3:::my-rag-bucket/*\"]  # CRITICAL: narrow resource\n    }]\n  })\n}\n```"
+    },
+    "Recommendation": {
+      "Text": "Apply **least privilege** to every Bedrock Agent execution role: scope `Action` and `Resource` to exactly what the agent needs, avoid AWS-managed `*FullAccess` policies, and always attach a **permissions boundary** so that future policy edits cannot exceed an approved ceiling. Treat agent roles as high-risk because prompt injection can weaponize any granted permission.",
+      "Url": "https://hub.prowler.com/check/bedrock_agent_role_least_privilege"
+    }
+  },
+  "Categories": [
+    "gen-ai"
+  ],
+  "DependsOn": [],
+  "RelatedTo": [],
+  "Notes": ""
+}

prowler/providers/aws/services/bedrock/bedrock_agent_role_least_privilege/bedrock_agent_role_least_privilege.py

@@ -0,0 +1,101 @@
+from prowler.lib.check.models import Check, Check_Report_AWS
+from prowler.providers.aws.services.bedrock.bedrock_agent_client import (
+    bedrock_agent_client,
+)
+from prowler.providers.aws.services.iam.iam_client import iam_client
+from prowler.providers.aws.services.iam.lib.policy import check_admin_access
+from prowler.providers.aws.services.iam.lib.privilege_escalation import (
+    check_privilege_escalation,
+)
+
+
+class bedrock_agent_role_least_privilege(Check):
+    """Ensure Bedrock Agent execution roles follow least privilege.
+
+    A Bedrock Agent's execution role is evaluated against three criteria:
+    - No AWS-managed ``*FullAccess`` policy attached.
+    - No attached or inline policy granting administrative access or known
+      privilege escalation combinations.
+    - A permissions boundary is configured on the role.
+    """
+
+    def execute(self) -> list[Check_Report_AWS]:
+        """Run the least-privilege evaluation across all Bedrock Agents.
+
+        Returns:
+            A list of ``Check_Report_AWS`` with one entry per agent. The
+            status is ``FAIL`` when any of the criteria above is violated,
+            or when the execution role cannot be resolved in IAM.
+        """
+        findings = []
+        roles_by_arn = {role.arn: role for role in (iam_client.roles or [])}
+
+        for agent in bedrock_agent_client.agents.values():
+            report = Check_Report_AWS(metadata=self.metadata(), resource=agent)
+            report.status = "PASS"
+            report.status_extended = (
+                f"Bedrock Agent {agent.name} execution role follows least privilege."
+            )
+
+            role = roles_by_arn.get(agent.role_arn) if agent.role_arn else None
+            if role is None:
+                report.status = "FAIL"
+                report.status_extended = (
+                    f"Bedrock Agent {agent.name} execution role could not be "
+                    f"resolved in IAM and cannot be evaluated for least privilege."
+                )
+                findings.append(report)
+                continue
+
+            violations = []
+
+            for policy in role.attached_policies:
+                policy_arn = policy.get("PolicyArn", "")
+                policy_name = policy.get("PolicyName") or policy_arn
+                if policy_arn.startswith(
+                    "arn:aws:iam::aws:policy/"
+                ) and policy_arn.endswith("FullAccess"):
+                    violations.append(
+                        f"managed policy {policy_name} grants full access"
+                    )
+                    continue
+                policy_obj = iam_client.policies.get(policy_arn)
+                if policy_obj is None or not policy_obj.document:
+                    continue
+                document = policy_obj.document
+                if check_admin_access(document):
+                    violations.append(
+                        f"managed policy {policy_name} grants administrative access"
+                    )
+                elif check_privilege_escalation(document):
+                    violations.append(
+                        f"managed policy {policy_name} allows privilege escalation"
+                    )
+
+            for inline_name in role.inline_policies:
+                policy_obj = iam_client.policies.get(f"{role.arn}:policy/{inline_name}")
+                if policy_obj is None or not policy_obj.document:
+                    continue
+                document = policy_obj.document
+                if check_admin_access(document):
+                    violations.append(
+                        f"inline policy {inline_name} grants administrative access"
+                    )
+                elif check_privilege_escalation(document):
+                    violations.append(
+                        f"inline policy {inline_name} allows privilege escalation"
+                    )
+
+            if not role.permissions_boundary:
+                violations.append("no permissions boundary configured")
+
+            if violations:
+                report.status = "FAIL"
+                report.status_extended = (
+                    f"Bedrock Agent {agent.name} execution role violates least "
+                    f"privilege: {'; '.join(violations)}."
+                )
+
+            findings.append(report)
+
+        return findings

prowler/providers/aws/services/bedrock/bedrock_api_key_no_long_term_credentials/bedrock_api_key_no_long_term_credentials.metadata.json

@@ -1,7 +1,7 @@
 {
   "Provider": "aws",
   "CheckID": "bedrock_api_key_no_long_term_credentials",
-  "CheckTitle": "Amazon Bedrock API key is expired",
+  "CheckTitle": "Amazon Bedrock long-term API key has expired",
   "CheckType": [
     "Software and Configuration Checks/AWS Security Best Practices",
     "Software and Configuration Checks/Industry and Regulatory Standards/AWS Foundational Security Best Practices",
@@ -14,23 +14,24 @@
   "Severity": "high",
   "ResourceType": "AwsIamUser",
   "ResourceGroup": "IAM",
-  "Description": "**Bedrock API keys** are evaluated for **lifetime** and **expiration**.\n\nThe finding identifies keys that are long-lived, set to expire far in the future, or configured to `never expire`, and distinguishes them from keys that have already expired.",
-  "Risk": "Long-lived or non-expiring keys enable persistent access if compromised.\n- Confidentiality: unauthorized inference and exposure of prompts/outputs\n- Availability/Cost: uncontrolled usage and spend spikes\n- Integrity: actions can continue without timely revocation or rotation",
+  "Description": "AWS recommends Amazon Bedrock **long-term API keys** only for **exploration**; production workloads should use **short-term API keys** (session-scoped, valid up to **12 hours**). This check fails for any active long-term Bedrock API key, escalating to `critical` severity when configured to **never expire**. Already-expired keys pass — they can no longer authenticate.",
+  "Risk": "Long-term Bedrock API keys persist beyond a session until their stored expiration, and keys set to **never expire** grant indefinite access until manually revoked, enabling unauthorized inference, uncontrolled usage and spend, and activity that continues past timely revocation.",
   "RelatedUrl": "",
   "AdditionalURLs": [
-    "https://docs.aws.amazon.com/ja_jp/bedrock/latest/userguide/getting-started-api-keys.html",
-    "https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#rotate-credentials",
-    "https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html"
+    "https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html",
+    "https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys-generate.html",
+    "https://docs.aws.amazon.com/IAM/latest/UserGuide/security-creds-programmatic-access.html#security-creds-alternatives-to-long-term-access-keys",
+    "https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#rotate-credentials"
   ],
   "Remediation": {
     "Code": {
       "CLI": "aws iam delete-service-specific-credential --user-name <username> --service-specific-credential-id <credential-id>",
       "NativeIaC": "",
-      "Other": "1. Sign in to the AWS Management Console and open IAM\n2. Go to Users > select <example_resource_name> > Security credentials\n3. In \"API keys for Amazon Bedrock\", find the non-expired key and click Delete\n4. Confirm deletion to remove the key (removes the long-term credential so the check passes)",
+      "Other": "1. Sign in to the AWS Management Console and open IAM\n2. Go to Users > select the IAM user backing the Bedrock API key > Security credentials\n3. In \"API keys for Amazon Bedrock\", select the active long-term key and click Delete\n4. For workloads that still need Bedrock access, generate a short-term API key from the Bedrock console (Short-term API keys tab), or call the Bedrock API with short-term credentials issued by AWS STS",
       "Terraform": ""
     },
     "Recommendation": {
-      "Text": "Prefer **short-term credentials** and **IAM roles**; avoid `never expire`.\n\nEnforce **least privilege**, strict **rotation**, and automatic **expiration** for any long-term key. Store secrets securely, monitor with audit logs, and revoke unused or stale keys quickly.",
+      "Text": "Use short-term Amazon Bedrock API keys for any non-exploratory workload — they are bound to the IAM principal's session, valid for at most 12 hours, scoped to a single Region, and can be auto-refreshed by the SDK. For existing long-term keys, delete the underlying IAM service-specific credential. If a long-term key must be retained for an exploration scenario, set an explicit short expiration and never select `never expire`.",
       "Url": "https://hub.prowler.com/check/bedrock_api_key_no_long_term_credentials"
     }
   },
@@ -40,5 +41,5 @@
   ],
   "DependsOn": [],
   "RelatedTo": [],
-  "Notes": "This check verifies that Amazon Bedrock API keys have expiration dates set. API keys without expiration dates are considered long-term credentials and pose a security risk. The check follows security best practices for credential management and the principle of least privilege."
+  "Notes": "AWS recommends against using long-term Amazon Bedrock API keys outside of exploration; production workloads should use short-term API keys (session-scoped, valid up to 12 hours). The IAM `ListServiceSpecificCredentials` API only enumerates long-term keys — short-term keys are session-scoped credentials that never appear here. The check therefore passes only when an existing long-term key has already expired and can no longer authenticate; any active long-term key fails, with critical severity when it is configured to never expire."
 }

prowler/providers/aws/services/bedrock/bedrock_api_key_no_long_term_credentials/bedrock_api_key_no_long_term_credentials.py

@@ -1,49 +1,62 @@
 from datetime import datetime, timezone
 
-from prowler.lib.check.models import Check, Check_Report_AWS
+from prowler.lib.check.models import Check, Check_Report_AWS, Severity
 from prowler.providers.aws.services.iam.iam_client import iam_client
 
+# Days threshold above which a Bedrock long-term API key is considered effectively non-expiring.
+NEVER_EXPIRES_THRESHOLD_DAYS = 10000
+
 
 class bedrock_api_key_no_long_term_credentials(Check):
-    """
-    Bedrock API keys should be short-lived to reduce the risk of unauthorized access.
-    This check verifies if there are any long-term Bedrock API keys.
-    If there are, it checks if they are expired or will be expired.
-    If they are expired, it will be marked as PASS.
-    If they are not expired, it will be marked as FAIL and the severity will be critical if the key will never expire.
+    """Amazon Bedrock long-term API keys should not be used outside of exploration.
+
+    AWS recommends short-term Bedrock API keys (session-scoped, valid up to 12 hours)
+    for any non-exploratory workload. ``ListServiceSpecificCredentials`` only enumerates
+    long-term keys, so every key inspected here is by definition a long-term credential.
+
+    PASS when the long-term key has already expired (it can no longer authenticate).
+    FAIL (critical) when the key is configured to never expire.
+    FAIL (high) for any other active long-term key.
     """
 
     def execute(self):
-        """
-        Execute the Bedrock API key no long-term credentials check.
-
-        Iterate over all the Bedrock API keys and check if they are expired or will be expired.
-
-        Returns:
-            List[Check_Report_AWS]: A list of report objects with the results of the check.
-        """
-
         findings = []
         for api_key in iam_client.service_specific_credentials:
             if api_key.service_name != "bedrock.amazonaws.com":
                 continue
-            if api_key.expiration_date:
-                report = Check_Report_AWS(metadata=self.metadata(), resource=api_key)
-                # Check if the expiration date is in the future
-                if api_key.expiration_date > datetime.now(timezone.utc):
-                    report.status = "FAIL"
-                    # Get the days until the expiration date
-                    days_until_expiration = (
-                        api_key.expiration_date - datetime.now(timezone.utc)
-                    ).days
-                    if days_until_expiration > 10000:
-                        self.Severity = "critical"
-                        report.status_extended = f"Long-term Bedrock API key {api_key.id} in user {api_key.user.name} exists and never expires."
-                    else:
-                        report.status_extended = f"Long-term Bedrock API key {api_key.id} in user {api_key.user.name} exists and will expire in {days_until_expiration} days."
-                else:
-                    report.status = "PASS"
-                    report.status_extended = f"Long-term Bedrock API key {api_key.id} in user {api_key.user.name} exists but has expired."
-                findings.append(report)
+            if not api_key.expiration_date:
+                continue
+
+            report = Check_Report_AWS(metadata=self.metadata(), resource=api_key)
+            now = datetime.now(timezone.utc)
+
+            if api_key.expiration_date <= now:
+                report.status = "PASS"
+                report.status_extended = (
+                    f"Bedrock long-term API key {api_key.id} in user "
+                    f"{api_key.user.name} has already expired and can no longer "
+                    f"authenticate."
+                )
+            elif (api_key.expiration_date - now).days > NEVER_EXPIRES_THRESHOLD_DAYS:
+                report.status = "FAIL"
+                report.check_metadata.Severity = Severity.critical
+                report.status_extended = (
+                    f"Bedrock long-term API key {api_key.id} in user "
+                    f"{api_key.user.name} is configured to never expire. Use "
+                    f"short-term Bedrock API keys (session-scoped, valid up to "
+                    f"12 hours) for non-exploratory workloads instead."
+                )
+            else:
+                days_until_expiration = (api_key.expiration_date - now).days
+                report.status = "FAIL"
+                report.status_extended = (
+                    f"Bedrock long-term API key {api_key.id} in user "
+                    f"{api_key.user.name} is active and will expire in "
+                    f"{days_until_expiration} days. Use short-term Bedrock API "
+                    f"keys (session-scoped, valid up to 12 hours) for "
+                    f"non-exploratory workloads instead."
+                )
+
+            findings.append(report)
 
         return findings

prowler/providers/aws/services/bedrock/bedrock_service.py

@@ -146,6 +146,7 @@ class BedrockAgent(AWSService):
         self.prompts = {}
         self.prompt_scanned_regions: set = set()
         self.__threading_call__(self._list_agents)
+        self.__threading_call__(self._get_agent, self.agents.values())
         self.__threading_call__(self._list_prompts)
         self.__threading_call__(self._get_prompt, self.prompts.values())
         self.__threading_call__(self._list_tags_for_resource, self.agents.values())
@@ -174,6 +175,22 @@ class BedrockAgent(AWSService):
                 f"{regional_client.region} -- {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
             )
 
+    def _get_agent(self, agent):
+        """Fetch full agent details to capture the execution role ARN.
+
+        list_agents only returns summaries (no agentResourceRoleArn), so we
+        need a per-agent GetAgent call. Stored on the Agent model for use by
+        checks like bedrock_agent_role_least_privilege.
+        """
+        logger.info("Bedrock Agent - Getting Agent...")
+        try:
+            agent_info = self.regional_clients[agent.region].get_agent(agentId=agent.id)
+            agent.role_arn = agent_info.get("agent", {}).get("agentResourceRoleArn")
+        except Exception as error:
+            logger.error(
+                f"{agent.region} -- {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
+            )
+
     def _list_prompts(self, regional_client):
         """List all prompts in a region."""
         logger.info("Bedrock Agent - Listing Prompts...")
@@ -236,6 +253,7 @@ class Agent(BaseModel):
     name: str
     arn: str
     guardrail_id: Optional[str] = None
+    role_arn: Optional[str] = None
     region: str
     tags: Optional[list] = []
 

prowler/providers/aws/services/cloudwatch/cloudwatch_changes_to_network_acls_alarm_configured/cloudwatch_changes_to_network_acls_alarm_configured.metadata.json

@@ -17,9 +17,8 @@
   "RelatedUrl": "",
   "AdditionalURLs": [
     "https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudwatch-alarms-for-cloudtrail.html",
-    "https://www.clouddefense.ai/compliance-rules/cis-v130/monitoring/cis-v130-4-11",
     "https://support.icompaas.com/support/solutions/articles/62000084031-ensure-a-log-metric-filter-and-alarm-exist-for-changes-to-network-access-control-lists-nacl-",
-    "https://trendmicro.com/trendaivisiononecloudriskmanagement/knowledge-base/aws/CloudWatchLogs/network-acl-changes-alarm.html",
+    "https://www.trendmicro.com/trendaivisiononecloudriskmanagement/knowledge-base/aws/CloudWatchLogs/network-acl-changes-alarm.html",
     "https://support.icompaas.com/support/solutions/articles/62000233134-4-11-ensure-network-access-control-list-nacl-changes-are-monitored-manual-"
   ],
   "Remediation": {

prowler/providers/aws/services/cloudwatch/cloudwatch_changes_to_network_acls_alarm_configured/cloudwatch_changes_to_network_acls_alarm_configured.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,16 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_changes_to_network_acls_alarm_configured(Check):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?CreateNetworkAcl.+\$\.eventName\s*=\s*.?CreateNetworkAclEntry.+\$\.eventName\s*=\s*.?DeleteNetworkAcl.+\$\.eventName\s*=\s*.?DeleteNetworkAclEntry.+\$\.eventName\s*=\s*.?ReplaceNetworkAclEntry.+\$\.eventName\s*=\s*.?ReplaceNetworkAclAssociation.?"
+        pattern = build_metric_filter_pattern(
+            event_names=[
+                "CreateNetworkAcl",
+                "CreateNetworkAclEntry",
+                "DeleteNetworkAcl",
+                "DeleteNetworkAclEntry",
+                "ReplaceNetworkAclEntry",
+                "ReplaceNetworkAclAssociation",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_changes_to_network_gateways_alarm_configured/cloudwatch_changes_to_network_gateways_alarm_configured.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,16 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_changes_to_network_gateways_alarm_configured(Check):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?CreateCustomerGateway.+\$\.eventName\s*=\s*.?DeleteCustomerGateway.+\$\.eventName\s*=\s*.?AttachInternetGateway.+\$\.eventName\s*=\s*.?CreateInternetGateway.+\$\.eventName\s*=\s*.?DeleteInternetGateway.+\$\.eventName\s*=\s*.?DetachInternetGateway.?"
+        pattern = build_metric_filter_pattern(
+            event_names=[
+                "CreateCustomerGateway",
+                "DeleteCustomerGateway",
+                "AttachInternetGateway",
+                "CreateInternetGateway",
+                "DeleteInternetGateway",
+                "DetachInternetGateway",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_changes_to_network_route_tables_alarm_configured/cloudwatch_changes_to_network_route_tables_alarm_configured.metadata.json

@@ -37,5 +37,5 @@
   ],
   "DependsOn": [],
   "RelatedTo": [],
-  "Notes": ""
+  "Notes": "Logging and Monitoring"
 }

prowler/providers/aws/services/cloudwatch/cloudwatch_changes_to_network_route_tables_alarm_configured/cloudwatch_changes_to_network_route_tables_alarm_configured.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,18 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_changes_to_network_route_tables_alarm_configured(Check):
     def execute(self):
-        pattern = r"\$\.eventSource\s*=\s*.?ec2.amazonaws.com.+\$\.eventName\s*=\s*.?CreateRoute.+\$\.eventName\s*=\s*.?CreateRouteTable.+\$\.eventName\s*=\s*.?ReplaceRoute.+\$\.eventName\s*=\s*.?ReplaceRouteTableAssociation.+\$\.eventName\s*=\s*.?DeleteRouteTable.+\$\.eventName\s*=\s*.?DeleteRoute.+\$\.eventName\s*=\s*.?DisassociateRouteTable.?"
+        pattern = build_metric_filter_pattern(
+            event_source="ec2.amazonaws.com",
+            event_names=[
+                "CreateRoute",
+                "CreateRouteTable",
+                "ReplaceRoute",
+                "ReplaceRouteTableAssociation",
+                "DeleteRouteTable",
+                "DeleteRoute",
+                "DisassociateRouteTable",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_changes_to_vpcs_alarm_configured/cloudwatch_changes_to_vpcs_alarm_configured.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,21 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_changes_to_vpcs_alarm_configured(Check):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?CreateVpc.+\$\.eventName\s*=\s*.?DeleteVpc.+\$\.eventName\s*=\s*.?ModifyVpcAttribute.+\$\.eventName\s*=\s*.?AcceptVpcPeeringConnection.+\$\.eventName\s*=\s*.?CreateVpcPeeringConnection.+\$\.eventName\s*=\s*.?DeleteVpcPeeringConnection.+\$\.eventName\s*=\s*.?RejectVpcPeeringConnection.+\$\.eventName\s*=\s*.?AttachClassicLinkVpc.+\$\.eventName\s*=\s*.?DetachClassicLinkVpc.+\$\.eventName\s*=\s*.?DisableVpcClassicLink.+\$\.eventName\s*=\s*.?EnableVpcClassicLink.?"
+        pattern = build_metric_filter_pattern(
+            event_names=[
+                "CreateVpc",
+                "DeleteVpc",
+                "ModifyVpcAttribute",
+                "AcceptVpcPeeringConnection",
+                "CreateVpcPeeringConnection",
+                "DeleteVpcPeeringConnection",
+                "RejectVpcPeeringConnection",
+                "AttachClassicLinkVpc",
+                "DetachClassicLinkVpc",
+                "DisableVpcClassicLink",
+                "EnableVpcClassicLink",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_and_alarm_for_aws_config_configuration_changes_enabled/cloudwatch_log_metric_filter_and_alarm_for_aws_config_configuration_changes_enabled.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -15,7 +16,15 @@ class cloudwatch_log_metric_filter_and_alarm_for_aws_config_configuration_change
     Check
 ):
     def execute(self):
-        pattern = r"\$\.eventSource\s*=\s*.?config.amazonaws.com.+\$\.eventName\s*=\s*.?StopConfigurationRecorder.+\$\.eventName\s*=\s*.?DeleteDeliveryChannel.+\$\.eventName\s*=\s*.?PutDeliveryChannel.+\$\.eventName\s*=\s*.?PutConfigurationRecorder.?"
+        pattern = build_metric_filter_pattern(
+            event_source="config.amazonaws.com",
+            event_names=[
+                "StopConfigurationRecorder",
+                "DeleteDeliveryChannel",
+                "PutDeliveryChannel",
+                "PutConfigurationRecorder",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_and_alarm_for_cloudtrail_configuration_changes_enabled/cloudwatch_log_metric_filter_and_alarm_for_cloudtrail_configuration_changes_enabled.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -15,7 +16,15 @@ class cloudwatch_log_metric_filter_and_alarm_for_cloudtrail_configuration_change
     Check
 ):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?CreateTrail.+\$\.eventName\s*=\s*.?UpdateTrail.+\$\.eventName\s*=\s*.?DeleteTrail.+\$\.eventName\s*=\s*.?StartLogging.+\$\.eventName\s*=\s*.?StopLogging.?"
+        pattern = build_metric_filter_pattern(
+            event_names=[
+                "CreateTrail",
+                "UpdateTrail",
+                "DeleteTrail",
+                "StartLogging",
+                "StopLogging",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_authentication_failures/cloudwatch_log_metric_filter_authentication_failures.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,10 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_log_metric_filter_authentication_failures(Check):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?ConsoleLogin.+\$\.errorMessage\s*=\s*.?Failed authentication.?"
+        pattern = build_metric_filter_pattern(
+            event_names=["ConsoleLogin"],
+            extra_clauses=[("errorMessage", "=", "Failed authentication")],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_aws_organizations_changes/cloudwatch_log_metric_filter_aws_organizations_changes.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,32 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_log_metric_filter_aws_organizations_changes(Check):
     def execute(self):
-        pattern = r"\$\.eventSource\s*=\s*.?organizations\.amazonaws\.com.+\$\.eventName\s*=\s*.?AcceptHandshake.+\$\.eventName\s*=\s*.?AttachPolicy.+\$\.eventName\s*=\s*.?CancelHandshake.+\$\.eventName\s*=\s*.?CreateAccount.+\$\.eventName\s*=\s*.?CreateOrganization.+\$\.eventName\s*=\s*.?CreateOrganizationalUnit.+\$\.eventName\s*=\s*.?CreatePolicy.+\$\.eventName\s*=\s*.?DeclineHandshake.+\$\.eventName\s*=\s*.?DeleteOrganization.+\$\.eventName\s*=\s*.?DeleteOrganizationalUnit.+\$\.eventName\s*=\s*.?DeletePolicy.+\$\.eventName\s*=\s*.?EnableAllFeatures.+\$\.eventName\s*=\s*.?EnablePolicyType.+\$\.eventName\s*=\s*.?InviteAccountToOrganization.+\$\.eventName\s*=\s*.?LeaveOrganization.+\$\.eventName\s*=\s*.?DetachPolicy.+\$\.eventName\s*=\s*.?DisablePolicyType.+\$\.eventName\s*=\s*.?MoveAccount.+\$\.eventName\s*=\s*.?RemoveAccountFromOrganization.+\$\.eventName\s*=\s*.?UpdateOrganizationalUnit.+\$\.eventName\s*=\s*.?UpdatePolicy.?"
+        pattern = build_metric_filter_pattern(
+            event_source="organizations.amazonaws.com",
+            event_names=[
+                "AcceptHandshake",
+                "AttachPolicy",
+                "CancelHandshake",
+                "CreateAccount",
+                "CreateOrganization",
+                "CreateOrganizationalUnit",
+                "CreatePolicy",
+                "DeclineHandshake",
+                "DeleteOrganization",
+                "DeleteOrganizationalUnit",
+                "DeletePolicy",
+                "EnableAllFeatures",
+                "EnablePolicyType",
+                "InviteAccountToOrganization",
+                "LeaveOrganization",
+                "DetachPolicy",
+                "DisablePolicyType",
+                "MoveAccount",
+                "RemoveAccountFromOrganization",
+                "UpdateOrganizationalUnit",
+                "UpdatePolicy",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_disable_or_scheduled_deletion_of_kms_cmk/cloudwatch_log_metric_filter_disable_or_scheduled_deletion_of_kms_cmk.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,10 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_log_metric_filter_disable_or_scheduled_deletion_of_kms_cmk(Check):
     def execute(self):
-        pattern = r"\$\.eventSource\s*=\s*.?kms.amazonaws.com.+\$\.eventName\s*=\s*.?DisableKey.+\$\.eventName\s*=\s*.?ScheduleKeyDeletion.?"
+        pattern = build_metric_filter_pattern(
+            event_source="kms.amazonaws.com",
+            event_names=["DisableKey", "ScheduleKeyDeletion"],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_for_s3_bucket_policy_changes/cloudwatch_log_metric_filter_for_s3_bucket_policy_changes.metadata.json

@@ -17,8 +17,7 @@
   "RelatedUrl": "",
   "AdditionalURLs": [
     "https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudwatch-alarms-for-cloudtrail.html",
-    "https://support.icompaas.com/support/solutions/articles/62000086674-ensure-a-log-metric-filter-and-alarm-exist-for-s3-bucket-policy-changes",
-    "https://www.tenable.com/audits/items/CIS_Amazon_Web_Services_Foundations_v5.0.0_L1.audit:8101350d6907e07863ac6748689b3e12"
+    "https://support.icompaas.com/support/solutions/articles/62000086674-ensure-a-log-metric-filter-and-alarm-exist-for-s3-bucket-policy-changes"
   ],
   "Remediation": {
     "Code": {

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_for_s3_bucket_policy_changes/cloudwatch_log_metric_filter_for_s3_bucket_policy_changes.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,20 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_log_metric_filter_for_s3_bucket_policy_changes(Check):
     def execute(self):
-        pattern = r"\$\.eventSource\s*=\s*.?s3.amazonaws.com.+\$\.eventName\s*=\s*.?PutBucketAcl.+\$\.eventName\s*=\s*.?PutBucketPolicy.+\$\.eventName\s*=\s*.?PutBucketCors.+\$\.eventName\s*=\s*.?PutBucketLifecycle.+\$\.eventName\s*=\s*.?PutBucketReplication.+\$\.eventName\s*=\s*.?DeleteBucketPolicy.+\$\.eventName\s*=\s*.?DeleteBucketCors.+\$\.eventName\s*=\s*.?DeleteBucketLifecycle.+\$\.eventName\s*=\s*.?DeleteBucketReplication.?"
+        pattern = build_metric_filter_pattern(
+            event_source="s3.amazonaws.com",
+            event_names=[
+                "PutBucketAcl",
+                "PutBucketPolicy",
+                "PutBucketCors",
+                "PutBucketLifecycle",
+                "PutBucketReplication",
+                "DeleteBucketPolicy",
+                "DeleteBucketCors",
+                "DeleteBucketLifecycle",
+                "DeleteBucketReplication",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_policy_changes/cloudwatch_log_metric_filter_policy_changes.metadata.json

@@ -17,7 +17,6 @@
   "RelatedUrl": "",
   "AdditionalURLs": [
     "https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudwatch-alarms-for-cloudtrail.html",
-    "https://www.clouddefense.ai/compliance-rules/cis-v140/monitoring/cis-v140-4-4",
     "https://www.intelligentdiscovery.io/controls/cloudwatch/cloudwatch-alarm-iam-policy-change"
   ],
   "Remediation": {

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_policy_changes/cloudwatch_log_metric_filter_policy_changes.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,26 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_log_metric_filter_policy_changes(Check):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?DeleteGroupPolicy.+\$\.eventName\s*=\s*.?DeleteRolePolicy.+\$\.eventName\s*=\s*.?DeleteUserPolicy.+\$\.eventName\s*=\s*.?PutGroupPolicy.+\$\.eventName\s*=\s*.?PutRolePolicy.+\$\.eventName\s*=\s*.?PutUserPolicy.+\$\.eventName\s*=\s*.?CreatePolicy.+\$\.eventName\s*=\s*.?DeletePolicy.+\$\.eventName\s*=\s*.?CreatePolicyVersion.+\$\.eventName\s*=\s*.?DeletePolicyVersion.+\$\.eventName\s*=\s*.?AttachRolePolicy.+\$\.eventName\s*=\s*.?DetachRolePolicy.+\$\.eventName\s*=\s*.?AttachUserPolicy.+\$\.eventName\s*=\s*.?DetachUserPolicy.+\$\.eventName\s*=\s*.?AttachGroupPolicy.+\$\.eventName\s*=\s*.?DetachGroupPolicy.?"
+        pattern = build_metric_filter_pattern(
+            event_names=[
+                "DeleteGroupPolicy",
+                "DeleteRolePolicy",
+                "DeleteUserPolicy",
+                "PutGroupPolicy",
+                "PutRolePolicy",
+                "PutUserPolicy",
+                "CreatePolicy",
+                "DeletePolicy",
+                "CreatePolicyVersion",
+                "DeletePolicyVersion",
+                "AttachRolePolicy",
+                "DetachRolePolicy",
+                "AttachUserPolicy",
+                "DetachUserPolicy",
+                "AttachGroupPolicy",
+                "DetachGroupPolicy",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_security_group_changes/cloudwatch_log_metric_filter_security_group_changes.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,16 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_log_metric_filter_security_group_changes(Check):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?AuthorizeSecurityGroupIngress.+\$\.eventName\s*=\s*.?AuthorizeSecurityGroupEgress.+\$\.eventName\s*=\s*.?RevokeSecurityGroupIngress.+\$\.eventName\s*=\s*.?RevokeSecurityGroupEgress.+\$\.eventName\s*=\s*.?CreateSecurityGroup.+\$\.eventName\s*=\s*.?DeleteSecurityGroup.?"
+        pattern = build_metric_filter_pattern(
+            event_names=[
+                "AuthorizeSecurityGroupIngress",
+                "AuthorizeSecurityGroupEgress",
+                "RevokeSecurityGroupIngress",
+                "RevokeSecurityGroupEgress",
+                "CreateSecurityGroup",
+                "DeleteSecurityGroup",
+            ],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_sign_in_without_mfa/cloudwatch_log_metric_filter_sign_in_without_mfa.metadata.json

@@ -21,7 +21,6 @@
     "https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudwatch-alarms-for-cloudtrail.html",
     "https://www.trendmicro.com/trendaivisiononecloudriskmanagement/knowledge-base/aws/CloudWatchLogs/console-sign-in-without-mfa.html",
     "https://www.tenable.com/audits/items/CIS_Amazon_Web_Services_Foundations_v3.0.0_L1.audit:1957056ee174cc38502d5f5f1864333b",
-    "https://www.clouddefense.ai/compliance-rules/gdpr/data-protection/log-metric-filter-console-login-mfa",
     "https://www.intelligentdiscovery.io/controls/cloudwatch/cloudwatch-alarm-no-mfa",
     "https://support.icompaas.com/support/solutions/articles/62000083605-ensure-a-log-metric-filter-and-alarm-exist-for-management-console-sign-in-without-mfa"
   ],

prowler/providers/aws/services/cloudwatch/cloudwatch_log_metric_filter_sign_in_without_mfa/cloudwatch_log_metric_filter_sign_in_without_mfa.py

@@ -6,6 +6,7 @@ from prowler.providers.aws.services.cloudwatch.cloudwatch_client import (
     cloudwatch_client,
 )
 from prowler.providers.aws.services.cloudwatch.lib.metric_filters import (
+    build_metric_filter_pattern,
     check_cloudwatch_log_metric_filter,
 )
 from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
@@ -13,7 +14,10 @@ from prowler.providers.aws.services.cloudwatch.logs_client import logs_client
 
 class cloudwatch_log_metric_filter_sign_in_without_mfa(Check):
     def execute(self):
-        pattern = r"\$\.eventName\s*=\s*.?ConsoleLogin.+\$\.additionalEventData\.MFAUsed\s*!=\s*.?Yes.?"
+        pattern = build_metric_filter_pattern(
+            event_names=["ConsoleLogin"],
+            extra_clauses=[("additionalEventData.MFAUsed", "!=", "Yes")],
+        )
         findings = []
 
         report = check_cloudwatch_log_metric_filter(

prowler/providers/aws/services/cloudwatch/lib/metric_filters.py

@@ -3,6 +3,45 @@ import re
 from prowler.lib.check.models import Check_Report_AWS
 
 
+def build_metric_filter_pattern(
+    *,
+    event_names: list[str] | None = None,
+    event_source: str | None = None,
+    extra_clauses: list[tuple[str, str, str]] | None = None,
+) -> str:
+    """Build a regex pattern to match a CloudWatch Logs filterPattern string.
+
+    All clauses must be present for the pattern to match, regardless of the
+    order in which AWS stores them. Event names are matched exactly, so a
+    short name like ``CreateRoute`` will not be satisfied by a longer one
+    like ``CreateRouteTable``.
+
+    Pass the result directly to ``check_cloudwatch_log_metric_filter``.
+
+    Args:
+        event_names: AWS API action names to require (``$.eventName``).
+        event_source: optional service principal to require (``$.eventSource``),
+            e.g. ``"ec2.amazonaws.com"``.
+        extra_clauses: additional conditions as ``(field, operator, value)``
+            tuples, where ``operator`` is ``"="`` or ``"!="``. Example:
+            ``("additionalEventData.MFAUsed", "!=", "Yes")``.
+
+    Returns:
+        A regex string for use with ``re.search(..., flags=re.DOTALL)``.
+    """
+    parts: list[str] = []
+    if event_source is not None:
+        parts.append(rf"(?=.*\$\.eventSource\s*=\s*.?{re.escape(event_source)})")
+    for name in event_names or []:
+        parts.append(rf"(?=.*\$\.eventName\s*=\s*.?{re.escape(name)}\b)")
+    for field, operator, value in extra_clauses or []:
+        if operator not in ("=", "!="):
+            raise ValueError(f"unsupported operator {operator!r}; expected '=' or '!='")
+        op = r"\s*!=\s*" if operator == "!=" else r"\s*=\s*"
+        parts.append(rf"(?=.*\$\.{re.escape(field)}{op}.?{re.escape(value)})")
+    return "".join(parts)
+
+
 def check_cloudwatch_log_metric_filter(
     metric_filter_pattern: str,
     trails: list,

prowler/providers/aws/services/iam/iam_service.py

@@ -103,6 +103,9 @@ class IAM(AWSService):
         self._get_user_temporary_credentials_usage()
         self.organization_features = []
         self._list_organizations_features()
+        # ListRoles does not echo PermissionsBoundary; backfill via GetRole.
+        if self.roles:
+            self.__threading_call__(self._get_role_permissions_boundary, self.roles)
         # List missing tags
         self.__threading_call__(self._list_tags, self.users)
         self.__threading_call__(self._list_tags, self.roles)
@@ -133,6 +136,7 @@ class IAM(AWSService):
                                 arn=role["Arn"],
                                 assume_role_policy=role["AssumeRolePolicyDocument"],
                                 is_service_role=is_service_role(role),
+                                permissions_boundary=role.get("PermissionsBoundary"),
                             )
                         )
         except ClientError as error:
@@ -460,6 +464,34 @@ class IAM(AWSService):
                 f"{self.region} -- {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
             )
 
+    def _get_role_permissions_boundary(self, role):
+        """Backfill ``role.permissions_boundary`` via ``GetRole``.
+
+        ``ListRoles`` does not return ``PermissionsBoundary`` in practice, so
+        the value is fetched per role and stored on the ``Role`` model.
+
+        Args:
+            role: The ``Role`` instance to enrich.
+        """
+        try:
+            response = self.client.get_role(RoleName=role.name)
+            role.permissions_boundary = response.get("Role", {}).get(
+                "PermissionsBoundary"
+            )
+        except ClientError as error:
+            if error.response["Error"]["Code"] == "NoSuchEntity":
+                logger.warning(
+                    f"{self.region} -- {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
+                )
+            else:
+                logger.error(
+                    f"{self.region} -- {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
+                )
+        except Exception as error:
+            logger.error(
+                f"{self.region} -- {error.__class__.__name__}[{error.__traceback__.tb_lineno}]: {error}"
+            )
+
     def _list_attached_role_policies(self):
         logger.info("IAM - List Attached Role Policies...")
         try:
@@ -1139,6 +1171,7 @@ class Role(BaseModel):
     is_service_role: bool
     attached_policies: list[dict] = []
     inline_policies: list[str] = []
+    permissions_boundary: Optional[dict] = None
     tags: Optional[list]
 
 

prowler/providers/stackit/services/objectstorage/objectstorage_access_key_expiration/objectstorage_access_key_expiration.metadata.json

@@ -0,0 +1,37 @@
+{
+  "Provider": "stackit",
+  "CheckID": "objectstorage_access_key_expiration",
+  "CheckTitle": "ObjectStorage access keys should have an expiration date",
+  "CheckType": [],
+  "ServiceName": "objectstorage",
+  "SubServiceName": "",
+  "ResourceIdTemplate": "",
+  "Severity": "high",
+  "ResourceType": "NotDefined",
+  "ResourceGroup": "IAM",
+  "Description": "**ObjectStorage access keys** should have an explicit expiration date. Long-lived credentials increase the blast radius of a credential compromise because they cannot expire on their own. Setting an expiration date enforces periodic rotation and limits the exposure window if a key is leaked.",
+  "Risk": "If an **ObjectStorage access key** is leaked, stolen, or forgotten without an expiration date, it remains usable indefinitely. An attacker can retain persistent access to object storage resources until the key is manually revoked.",
+  "RelatedUrl": "",
+  "AdditionalURLs": [
+    "https://docs.stackit.cloud/products/storage/object-storage/",
+    "https://docs.stackit.cloud/products/storage/object-storage/how-tos/create-and-delete-object-storage-credentials/"
+  ],
+  "Remediation": {
+    "Code": {
+      "CLI": "",
+      "NativeIaC": "",
+      "Other": "1. In the STACKIT Portal navigate to Object Storage > Access Keys. 2. Delete the non-expiring access key. 3. Create a new access key with an expiration date appropriate for your rotation policy (e.g. 90 days). 4. Update all applications and services that use the old key with the new credentials.",
+      "Terraform": ""
+    },
+    "Recommendation": {
+      "Text": "Create **ObjectStorage access keys** with an explicit expiration date and establish a rotation process. Delete non-expiring keys and replace them with time-limited credentials. A rotation period of **90 days or less** is recommended.",
+      "Url": "https://hub.prowler.com/check/objectstorage_access_key_expiration"
+    }
+  },
+  "Categories": [
+    "identity-access"
+  ],
+  "DependsOn": [],
+  "RelatedTo": [],
+  "Notes": "Access keys are scoped to credentials groups. This check evaluates all access keys across all credentials groups in the project."
+}

prowler/providers/stackit/services/objectstorage/objectstorage_access_key_expiration/objectstorage_access_key_expiration.py

@@ -0,0 +1,27 @@
+from prowler.lib.check.models import Check, CheckReportStackIT
+from prowler.providers.stackit.services.objectstorage.objectstorage_client import (
+    objectstorage_client,
+)
+
+
+class objectstorage_access_key_expiration(Check):
+    def execute(self):
+        findings = []
+        for key in objectstorage_client.access_keys:
+            report = CheckReportStackIT(
+                metadata=self.metadata(),
+                resource=key,
+            )
+            report.resource_id = key.key_id
+            report.resource_name = key.display_name
+            report.location = key.region
+
+            if key.has_expiration():
+                report.status = "PASS"
+                report.status_extended = f"Access key {key.display_name} has an expiration date set ({key.expires})."
+            else:
+                report.status = "FAIL"
+                report.status_extended = f"Access key {key.display_name} has no expiration date and never rotates."
+
+            findings.append(report)
+        return findings

prowler/providers/stackit/services/objectstorage/objectstorage_bucket_object_lock_enabled/objectstorage_bucket_object_lock_enabled.metadata.json

@@ -0,0 +1,37 @@
+{
+  "Provider": "stackit",
+  "CheckID": "objectstorage_bucket_object_lock_enabled",
+  "CheckTitle": "ObjectStorage buckets should have S3 Object Lock enabled",
+  "CheckType": [],
+  "ServiceName": "objectstorage",
+  "SubServiceName": "",
+  "ResourceIdTemplate": "",
+  "Severity": "high",
+  "ResourceType": "NotDefined",
+  "ResourceGroup": "storage",
+  "Description": "**S3 Object Lock** prevents objects from being deleted or overwritten for a fixed period or indefinitely. Enabling it protects against accidental deletion and ransomware by enforcing a **write-once-read-many (WORM)** model. Object Lock can only be enabled when the bucket is created.",
+  "Risk": "Without **Object Lock**, objects can be deleted or overwritten at any time, increasing the risk of data loss from accidental deletion, malicious actors, or ransomware. Backups and compliance data are particularly vulnerable.",
+  "RelatedUrl": "",
+  "AdditionalURLs": [
+    "https://docs.stackit.cloud/products/storage/object-storage/",
+    "https://docs.stackit.cloud/products/storage/object-storage/how-tos/object-lock-bucket/"
+  ],
+  "Remediation": {
+    "Code": {
+      "CLI": "",
+      "NativeIaC": "",
+      "Other": "Object Lock must be enabled at bucket creation time and cannot be enabled on an existing bucket. Create a new bucket with Object Lock enabled and migrate your data to it.",
+      "Terraform": ""
+    },
+    "Recommendation": {
+      "Text": "Create **ObjectStorage buckets** with S3 Object Lock enabled for workloads that require data immutability, compliance archiving, or ransomware protection. Object Lock cannot be retroactively enabled on existing buckets.",
+      "Url": "https://hub.prowler.com/check/objectstorage_bucket_object_lock_enabled"
+    }
+  },
+  "Categories": [
+    "resilience"
+  ],
+  "DependsOn": [],
+  "RelatedTo": [],
+  "Notes": "Object Lock can only be activated at bucket creation. Buckets without Object Lock are not necessarily misconfigured — evaluate based on the sensitivity and compliance requirements of the stored data."
+}

prowler/providers/stackit/services/objectstorage/objectstorage_bucket_object_lock_enabled/objectstorage_bucket_object_lock_enabled.py

@@ -0,0 +1,31 @@
+from prowler.lib.check.models import Check, CheckReportStackIT
+from prowler.providers.stackit.services.objectstorage.objectstorage_client import (
+    objectstorage_client,
+)
+
+
+class objectstorage_bucket_object_lock_enabled(Check):
+    def execute(self):
+        findings = []
+        for bucket in objectstorage_client.buckets:
+            report = CheckReportStackIT(
+                metadata=self.metadata(),
+                resource=bucket,
+            )
+            report.resource_id = bucket.name
+            report.resource_name = bucket.name
+            report.location = bucket.region
+
+            if bucket.object_lock_enabled:
+                report.status = "PASS"
+                report.status_extended = (
+                    f"Bucket {bucket.name} has S3 Object Lock enabled."
+                )
+            else:
+                report.status = "FAIL"
+                report.status_extended = (
+                    f"Bucket {bucket.name} does not have S3 Object Lock enabled."
+                )
+
+            findings.append(report)
+        return findings

prowler/providers/stackit/services/objectstorage/objectstorage_bucket_retention_policy/objectstorage_bucket_retention_policy.metadata.json

@@ -0,0 +1,39 @@
+{
+  "Provider": "stackit",
+  "CheckID": "objectstorage_bucket_retention_policy",
+  "CheckTitle": "ObjectStorage buckets should have a default retention policy configured",
+  "CheckType": [],
+  "ServiceName": "objectstorage",
+  "SubServiceName": "",
+  "ResourceIdTemplate": "",
+  "Severity": "medium",
+  "ResourceType": "NotDefined",
+  "ResourceGroup": "storage",
+  "Description": "An **ObjectStorage default retention policy** automatically applies a minimum retention period to every object uploaded to the bucket, preventing deletion or overwriting before the period expires. Without it, objects can be removed immediately after upload, undermining compliance and data durability requirements.",
+  "Risk": "Buckets without a **default retention policy** offer no automatic protection against premature object deletion. Compliance data, audit logs, and backups may be deleted before their required retention period elapses.",
+  "RelatedUrl": "",
+  "AdditionalURLs": [
+    "https://docs.stackit.cloud/products/storage/object-storage/",
+    "https://docs.stackit.cloud/products/storage/object-storage/how-tos/object-lock-default-retention/"
+  ],
+  "Remediation": {
+    "Code": {
+      "CLI": "",
+      "NativeIaC": "",
+      "Other": "Use the STACKIT Object Storage API or Portal to set a default retention policy on the bucket. Choose COMPLIANCE mode for strict immutability or GOVERNANCE mode to allow privileged users to override the policy.",
+      "Terraform": ""
+    },
+    "Recommendation": {
+      "Text": "Configure a **default retention policy** on every bucket that stores compliance-relevant or sensitive data. Choose `COMPLIANCE` mode for regulatory requirements and `GOVERNANCE` mode when administrative overrides are acceptable.",
+      "Url": "https://hub.prowler.com/check/objectstorage_bucket_retention_policy"
+    }
+  },
+  "Categories": [
+    "resilience"
+  ],
+  "DependsOn": [],
+  "RelatedTo": [
+    "objectstorage_bucket_object_lock_enabled"
+  ],
+  "Notes": "A default retention policy requires Object Lock to be enabled on the bucket. Buckets without Object Lock cannot have a retention policy."
+}

prowler/providers/stackit/services/objectstorage/objectstorage_bucket_retention_policy/objectstorage_bucket_retention_policy.py

@@ -0,0 +1,30 @@
+from prowler.lib.check.models import Check, CheckReportStackIT
+from prowler.providers.stackit.services.objectstorage.objectstorage_client import (
+    objectstorage_client,
+)
+
+
+class objectstorage_bucket_retention_policy(Check):
+    def execute(self):
+        findings = []
+        for bucket in objectstorage_client.buckets:
+            report = CheckReportStackIT(
+                metadata=self.metadata(),
+                resource=bucket,
+            )
+            report.resource_id = bucket.name
+            report.resource_name = bucket.name
+            report.location = bucket.region
+
+            if bucket.retention_days and bucket.retention_days > 0:
+                report.status = "PASS"
+                report.status_extended = (
+                    f"Bucket {bucket.name} has a default retention policy of "
+                    f"{bucket.retention_days} day(s) in {bucket.retention_mode} mode."
+                )
+            else:
+                report.status = "FAIL"
+                report.status_extended = f"Bucket {bucket.name} does not have a default retention policy configured."
+
+            findings.append(report)
+        return findings

prowler/providers/stackit/services/objectstorage/objectstorage_client.py

@@ -0,0 +1,6 @@
+from prowler.providers.common.provider import Provider
+from prowler.providers.stackit.services.objectstorage.objectstorage_service import (
+    ObjectStorageService,
+)
+
+objectstorage_client = ObjectStorageService(Provider.get_global_provider())

prowler/providers/stackit/services/objectstorage/objectstorage_service.py

@@ -0,0 +1,306 @@
+import json
+from datetime import datetime, timezone
+from typing import Optional
+
+from pydantic.v1 import BaseModel
+
+from prowler.lib.logger import logger
+from prowler.providers.stackit.stackit_provider import StackitProvider, suppress_stderr
+
+
+class ObjectStorageService:
+    def __init__(self, provider: StackitProvider):
+        self.provider = provider
+        self.project_id = provider.identity.project_id
+        self.regional_clients = provider.generate_regional_clients("objectstorage")
+
+        self.buckets: list[Bucket] = []
+        self.access_keys: list[AccessKey] = []
+
+        self._fetch_all_regions()
+
+    def _fetch_all_regions(self):
+        for region, client in self.regional_clients.items():
+            try:
+                self._list_buckets(client, region)
+                self._list_access_keys(client, region)
+            except Exception as error:
+                if getattr(error, "status", None) == 404:
+                    logger.info(
+                        f"StackIT project {self.project_id} has no ObjectStorage "
+                        f"presence in region {region}; skipping."
+                    )
+                    continue
+                raise
+
+    def _handle_api_call(self, api_function, *args, **kwargs):
+        try:
+            with suppress_stderr():
+                return api_function(*args, **kwargs)
+        except Exception as e:
+            self.provider.handle_api_error(e)
+            raise
+
+    def _list_buckets(self, client, region: str):
+        response = self._handle_api_call(
+            client.list_buckets, project_id=self.project_id, region=region
+        )
+
+        buckets_list = getattr(response, "buckets", None) or []
+        if isinstance(response, dict):
+            buckets_list = response.get("buckets", [])
+
+        for bucket_data in buckets_list:
+            try:
+                if hasattr(bucket_data, "name"):
+                    name = bucket_data.name
+                    object_lock_enabled = getattr(
+                        bucket_data, "object_lock_enabled", False
+                    )
+                elif isinstance(bucket_data, dict):
+                    name = bucket_data.get("name", "")
+                    object_lock_enabled = bucket_data.get("objectLockEnabled", False)
+                else:
+                    continue
+            except Exception as e:
+                logger.error(f"Error processing bucket: {e}")
+                continue
+
+            retention_days, retention_mode = self._get_default_retention(
+                client, region, name
+            )
+
+            self.buckets.append(
+                Bucket(
+                    name=name,
+                    region=region,
+                    project_id=self.project_id,
+                    object_lock_enabled=object_lock_enabled,
+                    retention_days=retention_days,
+                    retention_mode=retention_mode,
+                )
+            )
+
+        logger.info(f"Listed {len(buckets_list)} buckets in {region}")
+
+    def _get_default_retention(
+        self, client, region: str, bucket_name: str
+    ) -> tuple[Optional[int], Optional[str]]:
+        try:
+            response = self._handle_api_call(
+                client.get_default_retention,
+                project_id=self.project_id,
+                region=region,
+                bucket_name=bucket_name,
+            )
+            days = getattr(response, "days", None)
+            mode = getattr(response, "mode", None)
+            if isinstance(response, dict):
+                days = response.get("days")
+                mode = response.get("mode")
+            return days, str(mode) if mode else None
+        except Exception as e:
+            if getattr(e, "status", None) == 404:
+                return None, None
+            raise
+
+    def _list_access_keys(self, client, region: str):
+        credentials_groups_response = self._handle_api_call(
+            client.list_credentials_groups, project_id=self.project_id, region=region
+        )
+
+        credentials_groups = (
+            getattr(credentials_groups_response, "credentials_groups", None) or []
+        )
+        if isinstance(credentials_groups_response, dict):
+            credentials_groups = credentials_groups_response.get(
+                "credentialsGroups",
+                credentials_groups_response.get("credentials_groups", []),
+            )
+
+        total_keys = 0
+
+        for credentials_group_data in credentials_groups:
+            try:
+                if isinstance(credentials_group_data, dict):
+                    credentials_group_id = credentials_group_data.get(
+                        "id",
+                        credentials_group_data.get(
+                            "groupId",
+                            credentials_group_data.get("credentialsGroupId", ""),
+                        ),
+                    )
+                    credentials_group_name = credentials_group_data.get(
+                        "displayName",
+                        credentials_group_data.get("name", credentials_group_id),
+                    )
+                else:
+                    credentials_group_id = (
+                        getattr(credentials_group_data, "id", None)
+                        or getattr(credentials_group_data, "group_id", None)
+                        or getattr(credentials_group_data, "credentials_group_id", "")
+                    )
+                    credentials_group_name = getattr(
+                        credentials_group_data,
+                        "display_name",
+                        getattr(credentials_group_data, "name", credentials_group_id),
+                    )
+            except Exception as e:
+                logger.error(f"Error processing credentials group: {e}")
+                continue
+
+            if not credentials_group_id:
+                continue
+
+            response = self._list_access_keys_response(
+                client, region, credentials_group_id
+            )
+            keys_list = self._extract_access_keys(response)
+
+            for key_data in keys_list:
+                try:
+                    if hasattr(key_data, "key_id"):
+                        key_id = key_data.key_id
+                        display_name = getattr(key_data, "display_name", key_id)
+                        expires = getattr(key_data, "expires", None)
+                    elif isinstance(key_data, dict):
+                        key_id = key_data.get("keyId", key_data.get("key_id", ""))
+                        display_name = key_data.get(
+                            "displayName", key_data.get("display_name", key_id)
+                        )
+                        expires = key_data.get("expires")
+                    else:
+                        continue
+
+                    if not key_id:
+                        continue
+
+                    self.access_keys.append(
+                        AccessKey(
+                            key_id=key_id,
+                            display_name=display_name,
+                            expires=expires,
+                            region=region,
+                            project_id=self.project_id,
+                            credentials_group_id=credentials_group_id,
+                            credentials_group_name=credentials_group_name,
+                        )
+                    )
+                except Exception as e:
+                    logger.error(f"Error processing access key: {e}")
+                    continue
+
+            total_keys += len(keys_list)
+
+        logger.info(f"Listed {total_keys} access keys in {region}")
+
+    def _list_access_keys_response(
+        self, client, region: str, credentials_group_id: str
+    ):
+        raw_method = None
+        if callable(
+            getattr(type(client), "list_access_keys_without_preload_content", None)
+        ):
+            raw_method = client.list_access_keys_without_preload_content
+        elif callable(vars(client).get("list_access_keys_without_preload_content")):
+            raw_method = vars(client)["list_access_keys_without_preload_content"]
+
+        if raw_method:
+            response = self._handle_api_call(
+                raw_method,
+                project_id=self.project_id,
+                region=region,
+                credentials_group=credentials_group_id,
+            )
+            self._raise_for_raw_response_status(response)
+            return response
+
+        return self._handle_api_call(
+            client.list_access_keys,
+            project_id=self.project_id,
+            region=region,
+            credentials_group=credentials_group_id,
+        )
+
+    def _raise_for_raw_response_status(self, response):
+        status = getattr(response, "status", None)
+        if status is None:
+            status = getattr(response, "status_code", None)
+        if isinstance(status, int) and status >= 400:
+            error = Exception(
+                f"StackIT ObjectStorage list_access_keys failed with status {status}"
+            )
+            error.status = status
+            self.provider.handle_api_error(error)
+            raise error
+
+    @staticmethod
+    def _extract_access_keys(response) -> list:
+        payload = response
+        if not isinstance(payload, (dict, list)):
+            json_method = getattr(response, "json", None)
+            if callable(json_method):
+                payload = json_method()
+            elif hasattr(response, "data"):
+                payload = ObjectStorageService._parse_raw_json(response.data)
+            elif hasattr(response, "text"):
+                payload = ObjectStorageService._parse_raw_json(response.text)
+
+        if isinstance(payload, dict):
+            return payload.get("accessKeys", payload.get("access_keys", []))
+        if isinstance(payload, list):
+            return payload
+        return getattr(response, "access_keys", None) or []
+
+    @staticmethod
+    def _parse_raw_json(raw):
+        if raw in (None, b"", ""):
+            return {}
+        if isinstance(raw, (bytes, bytearray)):
+            raw = raw.decode("utf-8")
+        if isinstance(raw, str):
+            return json.loads(raw)
+        return raw
+
+
+class Bucket(BaseModel):
+    name: str
+    region: str
+    project_id: str
+    object_lock_enabled: bool = False
+    retention_days: Optional[int] = None
+    retention_mode: Optional[str] = None
+
+
+class AccessKey(BaseModel):
+    key_id: str
+    display_name: str
+    # None or a sentinel year-0001 date string means the key never expires.
+    expires: Optional[str] = None
+    region: str
+    project_id: str
+    credentials_group_id: Optional[str] = None
+    credentials_group_name: Optional[str] = None
+
+    def has_expiration(self) -> bool:
+        """Return True if the key has a real (non-sentinel) expiration date."""
+        if not self.expires:
+            return False
+        try:
+            expires_str = self.expires.replace("Z", "+00:00")
+            dt = datetime.fromisoformat(expires_str)
+            # Year 0001 (or earlier) is the SDK sentinel for "never expires"
+            return dt.year > 1
+        except (ValueError, AttributeError):
+            return False
+
+    def expires_within_days(self, days: int) -> bool:
+        """Return True if the key expires within the given number of days from now."""
+        if not self.has_expiration():
+            return False
+        expires_str = self.expires.replace("Z", "+00:00")
+        dt = datetime.fromisoformat(expires_str)
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        delta = dt - datetime.now(tz=timezone.utc)
+        return delta.days <= days

prowler/providers/stackit/stackit_provider.py

@@ -15,6 +15,7 @@ from colorama import Style
 # loader and surfacing as a misleading empty report.
 from stackit.core.configuration import Configuration
 from stackit.iaas import DefaultApi as IaasDefaultApi
+from stackit.objectstorage import DefaultApi as ObjectStorageDefaultApi
 from stackit.resourcemanager import DefaultApi as ResourceManagerDefaultApi
 
 from prowler.config.config import (
@@ -224,11 +225,17 @@ class StackitProvider(Provider):
             return json_regions.intersection(audited_regions)
         return json_regions
 
+    _SERVICE_API_CLASS = {
+        "iaas": IaasDefaultApi,
+        "objectstorage": ObjectStorageDefaultApi,
+    }
+
     def generate_regional_clients(self, service: str = "iaas") -> dict:
         """Generate regional API clients for the given service.
 
         Returns dict: {"eu01": DefaultApi_client, "eu02": DefaultApi_client}
         """
+        api_class = self._SERVICE_API_CLASS.get(service, IaasDefaultApi)
         regional_clients = {}
         service_regions = self.get_available_service_regions(
             service, self._audited_regions
@@ -240,7 +247,7 @@ class StackitProvider(Provider):
                     self._service_account_key_path,
                     self._service_account_key,
                 )
-                client = IaasDefaultApi(config)
+                client = api_class(config)
                 client.region = region  # Attach region attribute
                 regional_clients[region] = client
 

prowler/providers/stackit/stackit_regions_by_service.json

@@ -5,6 +5,12 @@
         "eu01",
         "eu02"
       ]
+    },
+    "objectstorage": {
+      "regions": [
+        "eu01",
+        "eu02"
+      ]
     }
   }
 }

pyproject.toml

@@ -95,6 +95,7 @@ dependencies = [
   "slack-sdk==3.39.0",
   "stackit-core==0.2.0",
   "stackit-iaas==1.4.0",
+  "stackit-objectstorage==1.4.0",
   "stackit-resourcemanager==0.8.0",
   "tabulate==0.9.0",
   "tzlocal==5.3.1",
@@ -123,7 +124,7 @@ maintainers = [{name = "Prowler Engineering", email = "engineering@prowler.com"}
 name = "prowler"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"
-version = "5.30.0"
+version = "5.30.1"
 
 [project.scripts]
 prowler = "prowler.__main__:prowler"

tests/config/schema/aws_schema_test.py

@@ -1,222 +0,0 @@
-"""AWS-specific schema coverage — the biggest provider, with the richest
-constraint surface (CIDRs, account IDs, port ranges, enums, thresholds)."""
-
-import pytest
-
-from prowler.config.schema.aws import AWSProviderConfig
-from prowler.config.schema.validator import validate_provider_config
-
-
-def _validate(raw):
-    return validate_provider_config("aws", raw, AWSProviderConfig)
-
-
-class Test_AWS_Threat_Detection_Thresholds:
-    """All threat detection thresholds are documented as fractions in 0..1.
-    The biggest risk of mistyping them is silently disabling the check."""
-
-    @pytest.mark.parametrize(
-        "key",
-        [
-            "threat_detection_privilege_escalation_threshold",
-            "threat_detection_enumeration_threshold",
-            "threat_detection_llm_jacking_threshold",
-        ],
-    )
-    def test_valid_boundary_values(self, key):
-        assert _validate({key: 0.0}) == {key: 0.0}
-        assert _validate({key: 1.0}) == {key: 1.0}
-        assert _validate({key: 0.5}) == {key: 0.5}
-
-    @pytest.mark.parametrize(
-        "key",
-        [
-            "threat_detection_privilege_escalation_threshold",
-            "threat_detection_enumeration_threshold",
-            "threat_detection_llm_jacking_threshold",
-        ],
-    )
-    def test_invalid_values_are_dropped(self, key):
-        # 20 instead of 0.2 — would never trigger
-        assert _validate({key: 20}) == {}
-        # negative
-        assert _validate({key: -0.1}) == {}
-        # string
-        assert _validate({key: "high"}) == {}
-
-
-class Test_AWS_Trusted_Account_Ids:
-    def test_valid_twelve_digit_ids(self):
-        ids = ["123456789012", "098765432109"]
-        assert _validate({"trusted_account_ids": ids}) == {"trusted_account_ids": ids}
-
-    def test_empty_list_is_valid(self):
-        assert _validate({"trusted_account_ids": []}) == {"trusted_account_ids": []}
-
-    def test_short_id_is_dropped(self):
-        assert _validate({"trusted_account_ids": ["12345"]}) == {}
-
-    def test_non_numeric_id_is_dropped(self):
-        assert _validate({"trusted_account_ids": ["1234abcd5678"]}) == {}
-
-    def test_id_with_dashes_is_dropped(self):
-        # Some users format account IDs as "1234-5678-9012"
-        assert _validate({"trusted_account_ids": ["1234-5678-9012"]}) == {}
-
-
-class Test_AWS_Trusted_Ips:
-    def test_single_ipv4_address(self):
-        assert _validate({"trusted_ips": ["1.2.3.4"]}) == {"trusted_ips": ["1.2.3.4"]}
-
-    def test_ipv4_cidr(self):
-        assert _validate({"trusted_ips": ["10.0.0.0/8"]}) == {
-            "trusted_ips": ["10.0.0.0/8"]
-        }
-
-    def test_ipv6_address(self):
-        assert _validate({"trusted_ips": ["2001:db8::1"]}) == {
-            "trusted_ips": ["2001:db8::1"]
-        }
-
-    def test_ipv6_cidr(self):
-        assert _validate({"trusted_ips": ["2001:db8::/32"]}) == {
-            "trusted_ips": ["2001:db8::/32"]
-        }
-
-    def test_mixed_list(self):
-        ips = ["1.2.3.4", "10.0.0.0/8", "2001:db8::1"]
-        assert _validate({"trusted_ips": ips}) == {"trusted_ips": ips}
-
-    def test_garbage_entry_is_dropped(self):
-        assert _validate({"trusted_ips": ["definitely-not-an-ip"]}) == {}
-
-    def test_cidr_with_host_bits_is_accepted(self):
-        # We use strict=False so "10.0.0.5/8" is accepted. This matches the
-        # behaviour of most security tools and avoids surprising users who
-        # paste real-world allowlists with non-canonical CIDR notation.
-        assert _validate({"trusted_ips": ["10.0.0.5/8"]}) == {
-            "trusted_ips": ["10.0.0.5/8"]
-        }
-
-
-class Test_AWS_Ports:
-    def test_valid_ports_in_range(self):
-        ports = [25, 80, 443, 65535, 1]
-        assert _validate({"ec2_high_risk_ports": ports}) == {
-            "ec2_high_risk_ports": ports
-        }
-
-    def test_port_zero_is_dropped(self):
-        # Port 0 is reserved and not a valid security signal.
-        assert _validate({"ec2_high_risk_ports": [0]}) == {}
-
-    def test_out_of_range_port_is_dropped(self):
-        assert _validate({"ec2_high_risk_ports": [70000]}) == {}
-
-    def test_negative_port_is_dropped(self):
-        assert _validate({"ec2_high_risk_ports": [-1]}) == {}
-
-
-class Test_AWS_Enums:
-    @pytest.mark.parametrize("level", ["CRITICAL", "HIGH", "MEDIUM", "LOW"])
-    def test_valid_severity_levels(self, level):
-        assert _validate({"ecr_repository_vulnerability_minimum_severity": level}) == {
-            "ecr_repository_vulnerability_minimum_severity": level
-        }
-
-    @pytest.mark.parametrize("level", ["critical", "Medium", "ANY", "", "X"])
-    def test_invalid_severity_levels_are_dropped(self, level):
-        assert _validate({"ecr_repository_vulnerability_minimum_severity": level}) == {}
-
-
-class Test_AWS_Detect_Secrets_Plugins:
-    def test_plugin_without_limit(self):
-        out = _validate({"detect_secrets_plugins": [{"name": "AWSKeyDetector"}]})
-        assert out == {"detect_secrets_plugins": [{"name": "AWSKeyDetector"}]}
-
-    def test_plugin_with_limit(self):
-        out = _validate(
-            {
-                "detect_secrets_plugins": [
-                    {"name": "Base64HighEntropyString", "limit": 6.0}
-                ]
-            }
-        )
-        assert out == {
-            "detect_secrets_plugins": [
-                {"name": "Base64HighEntropyString", "limit": 6.0}
-            ]
-        }
-
-    def test_plugin_missing_name_drops_whole_field(self):
-        # ``name`` is required by the upstream library.
-        out = _validate({"detect_secrets_plugins": [{"limit": 6.0}]})
-        assert out == {}
-
-    def test_extra_plugin_kwargs_pass_through(self):
-        # Plugins can have arbitrary extra params (extra="allow" on the
-        # nested model). They must round-trip.
-        out = _validate(
-            {
-                "detect_secrets_plugins": [
-                    {"name": "Custom", "my_param": "abc", "other": 42}
-                ]
-            }
-        )
-        assert out == {
-            "detect_secrets_plugins": [
-                {"name": "Custom", "my_param": "abc", "other": 42}
-            ]
-        }
-
-
-class Test_AWS_Booleans:
-    @pytest.mark.parametrize(
-        "key",
-        [
-            "mute_non_default_regions",
-            "verify_premium_support_plans",
-            "check_rds_instance_replicas",
-        ],
-    )
-    def test_true_and_false_round_trip(self, key):
-        assert _validate({key: True}) == {key: True}
-        assert _validate({key: False}) == {key: False}
-
-    def test_yaml_style_boolean_coercion(self):
-        # YAML can produce Python str "true"/"yes" if the user quoted it.
-        # Pydantic v2 will refuse string booleans by default. Verify it is
-        # dropped, not silently treated as True (which would be dangerous
-        # for verify_premium_support_plans).
-        out = _validate({"verify_premium_support_plans": "yes"})
-        # Pydantic actually DOES coerce "yes"/"no"/"true"/"false" in lax mode.
-        # We accept either outcome but require it to be a real bool.
-        if "verify_premium_support_plans" in out:
-            assert isinstance(out["verify_premium_support_plans"], bool)
-
-
-class Test_AWS_Full_Default_Config_Round_Trips:
-    """Loading the real shipped defaults through the schema must produce
-    exactly the same dict. This is the regression sentinel for backwards
-    compatibility."""
-
-    def test_full_default_config_round_trip(self):
-        # Subset that mirrors the shipped config.yaml semantics.
-        raw = {
-            "mute_non_default_regions": False,
-            "disallowed_regions": ["me-south-1", "me-central-1"],
-            "max_unused_access_keys_days": 45,
-            "max_ec2_instance_age_in_days": 180,
-            "trusted_account_ids": [],
-            "trusted_ips": [],
-            "ecr_repository_vulnerability_minimum_severity": "MEDIUM",
-            "threat_detection_privilege_escalation_threshold": 0.2,
-            "threat_detection_enumeration_threshold": 0.3,
-            "threat_detection_llm_jacking_threshold": 0.4,
-            "ec2_high_risk_ports": [25, 110, 8088],
-            "detect_secrets_plugins": [
-                {"name": "AWSKeyDetector"},
-                {"name": "Base64HighEntropyString", "limit": 6.0},
-            ],
-        }
-        assert _validate(raw) == raw

tests/config/schema/bounds_test.py

@@ -1,398 +0,0 @@
-"""Boundary tests for the safety bounds added on top of the upstream schemas.
-
-Each parametrised case checks (a) the min and max values are accepted and
-(b) one step outside the range is rejected. Custom validators (semver,
-EKS minor, dotted version, port range, account IDs, IPs) get focused
-positive/negative tests.
-
-Tests use the public adapter ``prowler.config.scan_config_schema``: a
-schema violation surfaces as a list of ``{"path", "message"}`` entries.
-This keeps the contract the Prowler App backend depends on under test.
-"""
-
-import pytest
-
-from prowler.config.scan_config_schema import validate_scan_config
-
-
-def _has_error_for(errors, path_substr: str) -> bool:
-    return any(path_substr in e["path"] for e in errors)
-
-
-# Each tuple: (provider, key, min_allowed, max_allowed)
-INT_BOUND_CASES = [
-    # AWS
-    ("aws", "max_unused_access_keys_days", 30, 180),
-    ("aws", "max_console_access_days", 30, 180),
-    ("aws", "max_unused_sagemaker_access_days", 7, 180),
-    ("aws", "max_security_group_rules", 1, 1000),
-    ("aws", "max_ec2_instance_age_in_days", 1, 1095),
-    ("aws", "recommended_cdk_bootstrap_version", 1, 100),
-    ("aws", "max_idle_disconnect_timeout_in_seconds", 60, 1800),
-    ("aws", "max_disconnect_timeout_in_seconds", 60, 3600),
-    ("aws", "max_session_duration_seconds", 600, 86400),
-    ("aws", "lambda_min_azs", 1, 6),
-    ("aws", "threat_detection_privilege_escalation_minutes", 5, 43200),
-    ("aws", "threat_detection_enumeration_minutes", 5, 43200),
-    ("aws", "threat_detection_llm_jacking_minutes", 5, 43200),
-    ("aws", "days_to_expire_threshold", 7, 365),
-    ("aws", "elb_min_azs", 1, 6),
-    ("aws", "elbv2_min_azs", 1, 6),
-    ("aws", "minimum_snapshot_retention_period", 1, 35),
-    ("aws", "max_days_secret_unused", 7, 365),
-    ("aws", "max_days_secret_unrotated", 1, 180),
-    ("aws", "min_kinesis_stream_retention_hours", 24, 8760),
-    # Azure
-    ("azure", "vm_backup_min_daily_retention_days", 7, 9999),
-    ("azure", "apim_threat_detection_llm_jacking_minutes", 5, 43200),
-    # GCP
-    ("gcp", "mig_min_zones", 1, 5),
-    ("gcp", "max_snapshot_age_days", 1, 1095),
-    ("gcp", "max_unused_account_days", 30, 365),
-    ("gcp", "storage_min_retention_days", 1, 3650),
-    # Kubernetes
-    ("kubernetes", "audit_log_maxbackup", 2, 1000),
-    ("kubernetes", "audit_log_maxsize", 10, 10000),
-    ("kubernetes", "audit_log_maxage", 7, 3650),
-    # M365
-    ("m365", "sign_in_frequency", 1, 168),
-    ("m365", "recommended_mailtips_large_audience_threshold", 5, 10000),
-    ("m365", "audit_log_age", 30, 3650),
-    # GitHub
-    ("github", "inactive_not_archived_days_threshold", 30, 3650),
-    # MongoDB Atlas
-    ("mongodbatlas", "max_service_account_secret_validity_hours", 1, 720),
-    # Cloudflare
-    ("cloudflare", "max_retries", 0, 10),
-    # Vercel
-    ("vercel", "days_to_expire_threshold", 7, 365),
-    ("vercel", "stale_token_threshold_days", 30, 3650),
-    ("vercel", "stale_invitation_threshold_days", 7, 365),
-    ("vercel", "max_owner_percentage", 1, 50),
-    ("vercel", "max_owners", 1, 1000),
-]
-
-
-FLOAT_THRESHOLD_FIELDS = [
-    ("aws", "threat_detection_privilege_escalation_threshold"),
-    ("aws", "threat_detection_enumeration_threshold"),
-    ("aws", "threat_detection_llm_jacking_threshold"),
-    ("azure", "apim_threat_detection_llm_jacking_threshold"),
-]
-
-
-class TestIntegerBounds:
-    """Each int field accepts both ends of its range and rejects ±1 outside."""
-
-    @pytest.mark.parametrize("provider, key, lo, hi", INT_BOUND_CASES)
-    def test_min_accepted(self, provider, key, lo, hi):
-        assert validate_scan_config({provider: {key: lo}}) == []
-
-    @pytest.mark.parametrize("provider, key, lo, hi", INT_BOUND_CASES)
-    def test_max_accepted(self, provider, key, lo, hi):
-        assert validate_scan_config({provider: {key: hi}}) == []
-
-    @pytest.mark.parametrize("provider, key, lo, hi", INT_BOUND_CASES)
-    def test_below_min_rejected(self, provider, key, lo, hi):
-        errors = validate_scan_config({provider: {key: lo - 1}})
-        assert _has_error_for(errors, f"{provider}.{key}"), errors
-
-    @pytest.mark.parametrize("provider, key, lo, hi", INT_BOUND_CASES)
-    def test_above_max_rejected(self, provider, key, lo, hi):
-        errors = validate_scan_config({provider: {key: hi + 1}})
-        assert _has_error_for(errors, f"{provider}.{key}"), errors
-
-
-class TestFloatThresholds:
-    """Threshold floats must stay within 0..1 inclusive."""
-
-    @pytest.mark.parametrize("provider, key", FLOAT_THRESHOLD_FIELDS)
-    def test_zero_and_one_accepted(self, provider, key):
-        assert validate_scan_config({provider: {key: 0.0}}) == []
-        assert validate_scan_config({provider: {key: 1.0}}) == []
-        assert validate_scan_config({provider: {key: 0.5}}) == []
-
-    @pytest.mark.parametrize("provider, key", FLOAT_THRESHOLD_FIELDS)
-    def test_negative_rejected(self, provider, key):
-        errors = validate_scan_config({provider: {key: -0.01}})
-        assert _has_error_for(errors, f"{provider}.{key}")
-
-    @pytest.mark.parametrize("provider, key", FLOAT_THRESHOLD_FIELDS)
-    def test_above_one_rejected(self, provider, key):
-        errors = validate_scan_config({provider: {key: 1.01}})
-        assert _has_error_for(errors, f"{provider}.{key}")
-
-
-class TestCloudWatchRetention:
-    """`log_group_retention_days` only accepts the AWS-approved enum values."""
-
-    @pytest.mark.parametrize("value", [1, 7, 30, 365, 731, 3653])
-    def test_valid_values_accepted(self, value):
-        assert validate_scan_config({"aws": {"log_group_retention_days": value}}) == []
-
-    @pytest.mark.parametrize("value", [0, 2, 42, 500, 999, 4000])
-    def test_invalid_values_rejected(self, value):
-        errors = validate_scan_config({"aws": {"log_group_retention_days": value}})
-        assert _has_error_for(errors, "aws.log_group_retention_days")
-
-
-class TestSemverValidator:
-    """AWS Fargate platform versions: X.Y.Z."""
-
-    @pytest.mark.parametrize("value", ["1.4.0", "1.0.0", "0.0.1", "10.20.30"])
-    def test_accepts_semver(self, value):
-        assert (
-            validate_scan_config({"aws": {"fargate_linux_latest_version": value}}) == []
-        )
-
-    @pytest.mark.parametrize("value", ["1.4", "1", "v1.4.0", "1.4.0-beta", "a.b.c", ""])
-    def test_rejects_non_semver(self, value):
-        errors = validate_scan_config({"aws": {"fargate_linux_latest_version": value}})
-        assert _has_error_for(errors, "aws.fargate_linux_latest_version")
-
-
-class TestEksVersionValidator:
-    """`eks_cluster_oldest_version_supported` expects MAJOR.MINOR."""
-
-    @pytest.mark.parametrize("value", ["1.28", "1.29", "1.30", "2.0"])
-    def test_accepts_minor(self, value):
-        assert (
-            validate_scan_config(
-                {"aws": {"eks_cluster_oldest_version_supported": value}}
-            )
-            == []
-        )
-
-    @pytest.mark.parametrize("value", ["1.28.0", "v1.28", "1", "1.x", ""])
-    def test_rejects_invalid(self, value):
-        errors = validate_scan_config(
-            {"aws": {"eks_cluster_oldest_version_supported": value}}
-        )
-        assert _has_error_for(errors, "aws.eks_cluster_oldest_version_supported")
-
-
-class TestEksLogTypesEnum:
-    """Only the documented log types are accepted."""
-
-    def test_full_enum_accepted(self):
-        assert (
-            validate_scan_config(
-                {
-                    "aws": {
-                        "eks_required_log_types": [
-                            "api",
-                            "audit",
-                            "authenticator",
-                            "controllerManager",
-                            "scheduler",
-                        ]
-                    }
-                }
-            )
-            == []
-        )
-
-    def test_unknown_type_rejected(self):
-        errors = validate_scan_config(
-            {"aws": {"eks_required_log_types": ["api", "telemetry"]}}
-        )
-        assert _has_error_for(errors, "aws.eks_required_log_types")
-
-
-class TestAzureDottedVersion:
-    """App Service versions accept 'X' and 'X.Y' but not 'X.Y.Z' or junk."""
-
-    @pytest.mark.parametrize("value", ["8.2", "3.12", "17"])
-    def test_accepts(self, value):
-        assert validate_scan_config({"azure": {"php_latest_version": value}}) == []
-        assert validate_scan_config({"azure": {"python_latest_version": value}}) == []
-        assert validate_scan_config({"azure": {"java_latest_version": value}}) == []
-
-    @pytest.mark.parametrize("value", ["8.2.0", "v8", "8.x", ""])
-    def test_rejects(self, value):
-        errors = validate_scan_config({"azure": {"php_latest_version": value}})
-        assert _has_error_for(errors, "azure.php_latest_version")
-
-
-class TestAzureTlsLiteralEnum:
-    """Only TLS 1.2 and 1.3 are tolerated by the recommended list."""
-
-    def test_accepted_versions(self):
-        assert (
-            validate_scan_config(
-                {"azure": {"recommended_minimal_tls_versions": ["1.2", "1.3"]}}
-            )
-            == []
-        )
-
-    @pytest.mark.parametrize("value", ["1.0", "1.1", "2.0", ""])
-    def test_unknown_version_rejected(self, value):
-        errors = validate_scan_config(
-            {"azure": {"recommended_minimal_tls_versions": [value]}}
-        )
-        assert _has_error_for(errors, "azure.recommended_minimal_tls_versions")
-
-
-class TestAzureRiskLevelLiteral:
-    """Defender attack-path risk level is a closed enum."""
-
-    @pytest.mark.parametrize("value", ["Low", "Medium", "High", "Critical"])
-    def test_accepted(self, value):
-        assert (
-            validate_scan_config(
-                {"azure": {"defender_attack_path_minimal_risk_level": value}}
-            )
-            == []
-        )
-
-    @pytest.mark.parametrize("value", ["low", "CRITICAL", "Severe", ""])
-    def test_rejected(self, value):
-        errors = validate_scan_config(
-            {"azure": {"defender_attack_path_minimal_risk_level": value}}
-        )
-        assert _has_error_for(errors, "azure.defender_attack_path_minimal_risk_level")
-
-
-class TestECRSeverityLiteral:
-    """ECR severity is a closed enum (with INFORMATIONAL allowed)."""
-
-    @pytest.mark.parametrize(
-        "value",
-        ["CRITICAL", "HIGH", "MEDIUM", "LOW", "INFORMATIONAL"],
-    )
-    def test_accepted(self, value):
-        assert (
-            validate_scan_config(
-                {"aws": {"ecr_repository_vulnerability_minimum_severity": value}}
-            )
-            == []
-        )
-
-    @pytest.mark.parametrize("value", ["URGENT", "low", "Crit", ""])
-    def test_rejected(self, value):
-        errors = validate_scan_config(
-            {"aws": {"ecr_repository_vulnerability_minimum_severity": value}}
-        )
-        assert _has_error_for(
-            errors, "aws.ecr_repository_vulnerability_minimum_severity"
-        )
-
-
-class TestPortRangeValidator:
-    """Each entry of `ec2_high_risk_ports` must be 1..65535 (0 is reserved)."""
-
-    def test_valid_ports(self):
-        assert (
-            validate_scan_config({"aws": {"ec2_high_risk_ports": [1, 22, 8080, 65535]}})
-            == []
-        )
-
-    @pytest.mark.parametrize("value", [-1, 0, 65536, 99999])
-    def test_invalid_port_rejected(self, value):
-        errors = validate_scan_config({"aws": {"ec2_high_risk_ports": [80, value]}})
-        assert _has_error_for(errors, "aws.ec2_high_risk_ports")
-
-
-class TestAccountIdsValidator:
-    """AWS account IDs are 12-digit strings."""
-
-    def test_valid(self):
-        assert (
-            validate_scan_config(
-                {"aws": {"trusted_account_ids": ["123456789012", "098765432109"]}}
-            )
-            == []
-        )
-
-    @pytest.mark.parametrize(
-        "value", ["12345", "12345678901", "1234567890123", "12345678901a"]
-    )
-    def test_invalid_rejected(self, value):
-        errors = validate_scan_config({"aws": {"trusted_account_ids": [value]}})
-        assert _has_error_for(errors, "aws.trusted_account_ids")
-
-
-class TestTrustedIpsValidator:
-    """Trusted IPs accept IPv4, IPv6, and CIDR; reject junk."""
-
-    @pytest.mark.parametrize(
-        "value",
-        ["1.2.3.4", "10.0.0.0/8", "2001:db8::1", "2001:db8::/32"],
-    )
-    def test_valid(self, value):
-        assert validate_scan_config({"aws": {"trusted_ips": [value]}}) == []
-
-    @pytest.mark.parametrize(
-        "value", ["not.an.ip", "1.2.3.300", "10.0.0.0/40", "::ffff:::"]
-    )
-    def test_invalid_rejected(self, value):
-        errors = validate_scan_config({"aws": {"trusted_ips": [value]}})
-        assert _has_error_for(errors, "aws.trusted_ips")
-
-
-class TestDetectSecretsEntropyBound:
-    """`detect_secrets_plugins[].limit` is Shannon entropy: 0..10."""
-
-    @pytest.mark.parametrize("value", [0.0, 3.5, 4.5, 8.0, 10.0])
-    def test_valid(self, value):
-        assert (
-            validate_scan_config(
-                {
-                    "aws": {
-                        "detect_secrets_plugins": [
-                            {"name": "Base64HighEntropyString", "limit": value}
-                        ]
-                    }
-                }
-            )
-            == []
-        )
-
-    @pytest.mark.parametrize("value", [-0.1, 10.01, 50])
-    def test_invalid(self, value):
-        errors = validate_scan_config(
-            {
-                "aws": {
-                    "detect_secrets_plugins": [
-                        {"name": "Base64HighEntropyString", "limit": value}
-                    ]
-                }
-            }
-        )
-        assert _has_error_for(errors, "aws.detect_secrets_plugins")
-
-
-class TestAdapterRobustness:
-    """Top-level adapter behaviour the Prowler App backend depends on."""
-
-    def test_non_dict_payload(self):
-        errors = validate_scan_config([1, 2, 3])
-        assert len(errors) == 1
-        assert errors[0]["path"] == "<root>"
-
-    def test_unknown_provider_section_tolerated(self):
-        # additionalProperties: True at the root level by design.
-        assert validate_scan_config({"newprovider": {"foo": "bar"}}) == []
-
-    def test_unknown_key_tolerated_by_pydantic_extra_allow(self):
-        # ProviderConfigBase has extra="allow" for forward compatibility.
-        assert validate_scan_config({"aws": {"completely_new_knob": 1}}) == []
-
-    def test_provider_section_must_be_mapping(self):
-        errors = validate_scan_config({"aws": "not a mapping"})
-        assert _has_error_for(errors, "aws")
-
-    def test_multiple_errors_surfaced(self):
-        errors = validate_scan_config(
-            {
-                "aws": {
-                    "max_unused_access_keys_days": 5,  # below min 30
-                    "max_security_group_rules": 99999,  # above max 1000
-                    "ec2_high_risk_ports": [80, 70000],  # port out of range
-                }
-            }
-        )
-        # All three should surface independently.
-        assert _has_error_for(errors, "aws.max_unused_access_keys_days")
-        assert _has_error_for(errors, "aws.max_security_group_rules")
-        assert _has_error_for(errors, "aws.ec2_high_risk_ports")

tests/config/schema/loader_integration_test.py

@@ -1,123 +0,0 @@
-"""End-to-end tests that exercise the real ``load_and_validate_config_file``
-through a temp YAML file. Anything that breaks here would break the actual
-``prowler aws -c …`` code path."""
-
-import logging
-import os
-import pathlib
-
-import pytest
-
-from prowler.config.config import load_and_validate_config_file
-
-
-@pytest.fixture
-def write_config(tmp_path):
-    def _write(content: str) -> str:
-        path = tmp_path / "config.yaml"
-        path.write_text(content)
-        return str(path)
-
-    return _write
-
-
-class Test_Loader_With_Schema_Integration:
-    def test_shipped_default_config_loads_without_warnings(self, caplog):
-        """The default ``prowler/config/config.yaml`` must round-trip every
-        provider WITHOUT emitting any schema warnings. If this fails,
-        someone added a key to the YAML without updating the schema."""
-        repo_root = pathlib.Path(os.path.dirname(os.path.realpath(__file__))).parents[2]
-        shipped = repo_root / "prowler" / "config" / "config.yaml"
-        with caplog.at_level(logging.WARNING, logger="prowler"):
-            for provider in [
-                "aws",
-                "azure",
-                "gcp",
-                "kubernetes",
-                "m365",
-                "github",
-                "mongodbatlas",
-                "cloudflare",
-                "vercel",
-            ]:
-                cfg = load_and_validate_config_file(provider, str(shipped))
-                # Provider always exists in the shipped file → non-empty.
-                assert cfg, f"{provider} returned an empty config"
-
-        offending = [
-            r.getMessage()
-            for r in caplog.records
-            if "prowler.config[" in r.getMessage()
-        ]
-        assert not offending, (
-            "Shipped config.yaml triggered schema warnings — schema or YAML out of sync:\n"
-            + "\n".join(offending)
-        )
-
-    def test_user_config_with_bad_threshold_falls_back(self, write_config, caplog):
-        path = write_config(
-            "aws:\n"
-            "  threat_detection_privilege_escalation_threshold: 5.0\n"
-            "  lambda_min_azs: 2\n"
-        )
-        with caplog.at_level(logging.WARNING, logger="prowler"):
-            cfg = load_and_validate_config_file("aws", path)
-        assert cfg == {"lambda_min_azs": 2}
-        assert any(
-            "threat_detection_privilege_escalation_threshold" in r.getMessage()
-            for r in caplog.records
-        )
-
-    def test_old_format_config_still_works(self, write_config):
-        # Old format = flat keys, no provider header.
-        path = write_config(
-            "max_ec2_instance_age_in_days: 90\n"
-            "ecr_repository_vulnerability_minimum_severity: HIGH\n"
-        )
-        cfg = load_and_validate_config_file("aws", path)
-        assert cfg == {
-            "max_ec2_instance_age_in_days": 90,
-            "ecr_repository_vulnerability_minimum_severity": "HIGH",
-        }
-
-    def test_unknown_keys_pass_through_via_loader(self, write_config):
-        path = write_config(
-            "aws:\n" "  third_party_plugin_setting: hello\n" "  lambda_min_azs: 2\n"
-        )
-        cfg = load_and_validate_config_file("aws", path)
-        assert cfg == {
-            "third_party_plugin_setting": "hello",
-            "lambda_min_azs": 2,
-        }
-
-    def test_quoted_numeric_is_coerced_via_loader(self, write_config):
-        # YAML quotes the number: ``"180"`` arrives as a Python str.
-        # The schema must coerce it to int so downstream comparisons work.
-        path = write_config('aws:\n  max_ec2_instance_age_in_days: "180"\n')
-        cfg = load_and_validate_config_file("aws", path)
-        assert cfg == {"max_ec2_instance_age_in_days": 180}
-        assert isinstance(cfg["max_ec2_instance_age_in_days"], int)
-
-    def test_invalid_yaml_shape_list_as_string_drops_key(self, write_config, caplog):
-        path = write_config(
-            "aws:\n"
-            "  disallowed_regions: me-south-1\n"  # forgot list dashes
-            "  lambda_min_azs: 2\n"
-        )
-        with caplog.at_level(logging.WARNING, logger="prowler"):
-            cfg = load_and_validate_config_file("aws", path)
-        assert cfg == {"lambda_min_azs": 2}
-        assert any("disallowed_regions" in r.getMessage() for r in caplog.records)
-
-    def test_other_providers_unaffected_by_aws_block(self, write_config):
-        path = write_config(
-            "aws:\n  max_ec2_instance_age_in_days: 90\n" "gcp:\n  mig_min_zones: 5\n"
-        )
-        assert load_and_validate_config_file("aws", path) == {
-            "max_ec2_instance_age_in_days": 90
-        }
-        assert load_and_validate_config_file("gcp", path) == {"mig_min_zones": 5}
-
-    def test_missing_provider_block_returns_empty(self, write_config):
-        path = write_config("aws:\n  max_ec2_instance_age_in_days: 90\n")
-        assert load_and_validate_config_file("azure", path) == {}

tests/config/schema/other_providers_schema_test.py

@@ -1,152 +0,0 @@
-"""Smaller-provider schema coverage. One happy path + one invalid path
-per field is enough to lock in the contract; the validator behaviour
-itself is covered exhaustively in validator_test.py."""
-
-import pytest
-
-from prowler.config.schema.registry import SCHEMAS
-from prowler.config.schema.validator import validate_provider_config
-
-
-def _validate(provider, raw):
-    return validate_provider_config(provider, raw, SCHEMAS[provider])
-
-
-class Test_Azure_Schema:
-    @pytest.mark.parametrize("level", ["Low", "Medium", "High", "Critical"])
-    def test_defender_risk_level_valid_values(self, level):
-        assert _validate(
-            "azure", {"defender_attack_path_minimal_risk_level": level}
-        ) == {"defender_attack_path_minimal_risk_level": level}
-
-    def test_defender_risk_level_lowercase_dropped(self):
-        # Case matters: the matching check uses Title-case comparison.
-        assert (
-            _validate("azure", {"defender_attack_path_minimal_risk_level": "high"})
-            == {}
-        )
-
-    def test_apim_threshold_in_range(self):
-        out = _validate("azure", {"apim_threat_detection_llm_jacking_threshold": 0.1})
-        assert out == {"apim_threat_detection_llm_jacking_threshold": 0.1}
-
-    def test_apim_threshold_out_of_range(self):
-        out = _validate("azure", {"apim_threat_detection_llm_jacking_threshold": 1.5})
-        assert out == {}
-
-    def test_vm_backup_retention_must_be_positive(self):
-        assert _validate("azure", {"vm_backup_min_daily_retention_days": 7}) == {
-            "vm_backup_min_daily_retention_days": 7
-        }
-        assert _validate("azure", {"vm_backup_min_daily_retention_days": 0}) == {}
-        assert _validate("azure", {"vm_backup_min_daily_retention_days": -1}) == {}
-
-
-class Test_GCP_Schema:
-    def test_valid_values_round_trip(self):
-        raw = {
-            "mig_min_zones": 2,
-            "max_snapshot_age_days": 90,
-            "max_unused_account_days": 180,
-            "storage_min_retention_days": 90,
-        }
-        assert _validate("gcp", raw) == raw
-
-    def test_zero_zone_count_dropped(self):
-        assert _validate("gcp", {"mig_min_zones": 0}) == {}
-
-
-class Test_Kubernetes_Schema:
-    def test_valid_values_round_trip(self):
-        raw = {
-            "audit_log_maxbackup": 10,
-            "audit_log_maxsize": 100,
-            "audit_log_maxage": 30,
-        }
-        assert _validate("kubernetes", raw) == raw
-
-    def test_negative_audit_log_dropped(self):
-        assert _validate("kubernetes", {"audit_log_maxage": -1}) == {}
-
-
-class Test_M365_Schema:
-    def test_valid_values_round_trip(self):
-        raw = {
-            "sign_in_frequency": 4,
-            "recommended_mailtips_large_audience_threshold": 25,
-            "audit_log_age": 90,
-        }
-        assert _validate("m365", raw) == raw
-
-    def test_negative_audit_log_age_dropped(self):
-        assert _validate("m365", {"audit_log_age": -10}) == {}
-
-
-class Test_GitHub_Schema:
-    def test_valid_threshold(self):
-        assert _validate("github", {"inactive_not_archived_days_threshold": 180}) == {
-            "inactive_not_archived_days_threshold": 180
-        }
-
-    def test_zero_threshold_dropped(self):
-        assert _validate("github", {"inactive_not_archived_days_threshold": 0}) == {}
-
-
-class Test_MongoDBAtlas_Schema:
-    def test_valid(self):
-        assert _validate(
-            "mongodbatlas", {"max_service_account_secret_validity_hours": 8}
-        ) == {"max_service_account_secret_validity_hours": 8}
-
-    def test_invalid_negative(self):
-        assert (
-            _validate("mongodbatlas", {"max_service_account_secret_validity_hours": -1})
-            == {}
-        )
-
-
-class Test_Cloudflare_Schema:
-    def test_zero_retries_allowed(self):
-        # 0 is explicitly documented as "disable retries" in config.yaml.
-        assert _validate("cloudflare", {"max_retries": 0}) == {"max_retries": 0}
-
-    def test_positive_retries_allowed(self):
-        assert _validate("cloudflare", {"max_retries": 3}) == {"max_retries": 3}
-
-    def test_negative_retries_dropped(self):
-        assert _validate("cloudflare", {"max_retries": -1}) == {}
-
-
-class Test_Vercel_Schema:
-    def test_owner_percentage_in_range(self):
-        assert _validate("vercel", {"max_owner_percentage": 20}) == {
-            "max_owner_percentage": 20
-        }
-        assert _validate("vercel", {"max_owner_percentage": 1}) == {
-            "max_owner_percentage": 1
-        }
-        assert _validate("vercel", {"max_owner_percentage": 50}) == {
-            "max_owner_percentage": 50
-        }
-
-    def test_owner_percentage_over_max_dropped(self):
-        # Tightened to 1..50 — anything above (incl. previous 100) is dropped.
-        assert _validate("vercel", {"max_owner_percentage": 51}) == {}
-        assert _validate("vercel", {"max_owner_percentage": 150}) == {}
-
-    def test_owner_percentage_zero_or_negative_dropped(self):
-        # 0 is no longer a valid configuration (defeats PoLP signal).
-        assert _validate("vercel", {"max_owner_percentage": 0}) == {}
-        assert _validate("vercel", {"max_owner_percentage": -1}) == {}
-
-    def test_full_default_config_round_trip(self):
-        raw = {
-            "stable_branches": ["main", "master"],
-            "days_to_expire_threshold": 7,
-            "stale_token_threshold_days": 90,
-            "stale_invitation_threshold_days": 30,
-            "max_owner_percentage": 20,
-            "max_owners": 3,
-            "secret_suffixes": ["_KEY", "_SECRET", "_TOKEN"],
-        }
-        assert _validate("vercel", raw) == raw

tests/config/schema/validator_test.py

@@ -1,175 +0,0 @@
-"""Behavioural tests for ``validate_provider_config``.
-
-The validator is the gatekeeper for every provider schema: its job is to
-keep backwards-compatible behaviour (no exceptions, drop only the bad
-keys) while loudly logging type mistakes.
-"""
-
-import logging
-
-import pytest
-
-from prowler.config.schema.aws import AWSProviderConfig
-from prowler.config.schema.registry import SCHEMAS
-from prowler.config.schema.validator import validate_provider_config
-
-
-class Test_Validate_Provider_Config_Contract:
-    """Generic invariants that must hold for any schema."""
-
-    def test_returns_empty_dict_when_raw_is_not_a_dict(self):
-        assert validate_provider_config("aws", None, AWSProviderConfig) == {}
-        assert validate_provider_config("aws", "string", AWSProviderConfig) == {}
-        assert validate_provider_config("aws", 42, AWSProviderConfig) == {}
-        assert validate_provider_config("aws", [], AWSProviderConfig) == {}
-
-    def test_returns_raw_unchanged_when_no_schema_registered(self):
-        raw = {"anything": "goes", "even": [1, 2, 3]}
-        assert validate_provider_config("mystery_provider", raw, None) == raw
-
-    def test_unknown_keys_pass_through_for_plugin_compatibility(self):
-        # Third-party plugins inject arbitrary keys; the schema must NOT
-        # filter them. This is the contract that lets the plugin ecosystem
-        # keep working when we add validation.
-        raw = {"plugin_custom_key": "foo", "lambda_min_azs": 2}
-        assert validate_provider_config("aws", raw, AWSProviderConfig) == {
-            "plugin_custom_key": "foo",
-            "lambda_min_azs": 2,
-        }
-
-    def test_empty_dict_returns_empty_dict(self):
-        assert validate_provider_config("aws", {}, AWSProviderConfig) == {}
-
-    def test_known_valid_value_passes_through_unchanged(self):
-        raw = {"max_ec2_instance_age_in_days": 180}
-        assert validate_provider_config("aws", raw, AWSProviderConfig) == {
-            "max_ec2_instance_age_in_days": 180
-        }
-
-
-class Test_Validate_Provider_Config_Coercion:
-    """Pydantic v2 coerces common type-mistakes automatically. We want to
-    keep that behaviour so quoted numerics in user configs ``Just Work``."""
-
-    def test_string_numeric_is_coerced_to_int(self):
-        out = validate_provider_config(
-            "aws", {"max_ec2_instance_age_in_days": "180"}, AWSProviderConfig
-        )
-        assert out == {"max_ec2_instance_age_in_days": 180}
-        assert isinstance(out["max_ec2_instance_age_in_days"], int)
-
-    def test_string_numeric_is_coerced_to_float(self):
-        out = validate_provider_config(
-            "aws",
-            {"threat_detection_privilege_escalation_threshold": "0.4"},
-            AWSProviderConfig,
-        )
-        assert out == {"threat_detection_privilege_escalation_threshold": 0.4}
-
-
-class Test_Validate_Provider_Config_Drops_Invalid_Keys:
-    """When a field fails validation, only that key is dropped from the
-    returned dict. The rest of the user's config is preserved so the
-    consumer's ``audit_config.get(key, default)`` falls back to its own
-    built-in default for the offending field and uses user values for
-    everything else."""
-
-    def test_out_of_range_threshold_is_dropped(self, caplog):
-        with caplog.at_level(logging.WARNING):
-            out = validate_provider_config(
-                "aws",
-                {
-                    "threat_detection_privilege_escalation_threshold": 2.0,
-                    "lambda_min_azs": 2,
-                },
-                AWSProviderConfig,
-            )
-        assert out == {"lambda_min_azs": 2}
-        assert any(
-            "threat_detection_privilege_escalation_threshold" in r.getMessage()
-            for r in caplog.records
-        )
-
-    def test_invalid_enum_is_dropped(self):
-        out = validate_provider_config(
-            "aws",
-            {"ecr_repository_vulnerability_minimum_severity": "medum"},
-            AWSProviderConfig,
-        )
-        assert out == {}
-
-    def test_wrong_shape_list_as_string_is_dropped(self):
-        # Classic YAML mistake: ``disallowed_regions: me-south-1`` without dashes.
-        # Pydantic refuses to silently treat a str as a single-element list,
-        # which is exactly the safety guarantee we want.
-        out = validate_provider_config(
-            "aws",
-            {"disallowed_regions": "me-south-1", "lambda_min_azs": 2},
-            AWSProviderConfig,
-        )
-        assert out == {"lambda_min_azs": 2}
-
-    def test_negative_positive_int_is_dropped(self):
-        out = validate_provider_config(
-            "aws", {"max_ec2_instance_age_in_days": -1}, AWSProviderConfig
-        )
-        assert out == {}
-
-    def test_zero_is_dropped_for_strictly_positive_field(self):
-        # max_ec2_instance_age_in_days is gt=0. Zero would silently cause every
-        # instance to FAIL the age check.
-        out = validate_provider_config(
-            "aws", {"max_ec2_instance_age_in_days": 0}, AWSProviderConfig
-        )
-        assert out == {}
-
-    def test_multiple_invalid_keys_yield_multiple_warnings(self, caplog):
-        with caplog.at_level(logging.WARNING):
-            out = validate_provider_config(
-                "aws",
-                {
-                    "max_ec2_instance_age_in_days": "nope",
-                    "ecr_repository_vulnerability_minimum_severity": "medum",
-                    "valid_extra_key": "kept",
-                },
-                AWSProviderConfig,
-            )
-        assert out == {"valid_extra_key": "kept"}
-        messages = " ".join(r.getMessage() for r in caplog.records)
-        assert "max_ec2_instance_age_in_days" in messages
-        assert "ecr_repository_vulnerability_minimum_severity" in messages
-
-    def test_warning_message_includes_provider_and_field(self, caplog):
-        with caplog.at_level(logging.WARNING):
-            validate_provider_config(
-                "aws",
-                {"threat_detection_privilege_escalation_threshold": 5.0},
-                AWSProviderConfig,
-            )
-        assert any(
-            "prowler.config[aws.threat_detection_privilege_escalation_threshold]"
-            in r.getMessage()
-            for r in caplog.records
-        )
-
-
-class Test_Schemas_Registry:
-    """Every provider mentioned in the YAML config must have a schema."""
-
-    @pytest.mark.parametrize(
-        "provider",
-        [
-            "aws",
-            "azure",
-            "gcp",
-            "kubernetes",
-            "m365",
-            "github",
-            "mongodbatlas",
-            "cloudflare",
-            "vercel",
-        ],
-    )
-    def test_schema_registered_for_provider(self, provider):
-        assert provider in SCHEMAS
-        assert SCHEMAS[provider] is not None

tests/dashboard/common_methods_test.py

@@ -0,0 +1,81 @@
+import pandas as pd
+from dash import dash_table
+
+from dashboard.common_methods import get_section_containers_generic
+
+
+def _datatable_column_ids(component):
+    """Collect the column ids of every DataTable in a Dash component tree."""
+    if isinstance(component, dash_table.DataTable):
+        return [[c["id"] for c in component.columns]]
+    children = getattr(component, "children", None)
+    if children is None:
+        return []
+    if not isinstance(children, (list, tuple)):
+        children = [children]
+    return [cols for child in children for cols in _datatable_column_ids(child)]
+
+
+def _df(**extra):
+    data = {
+        "REQUIREMENTS_ID": ["req1"],
+        "STATUS": ["PASS"],
+        "CHECKID": ["check1"],
+        "REGION": ["us-east-1"],
+        "ACCOUNTID": ["123"],
+        "RESOURCEID": ["res1"],
+    }
+    data.update(extra)
+    return pd.DataFrame(data)
+
+
+class TestGetSectionContainersGeneric:
+    def test_one_container_per_section(self):
+        """One outer container per distinct section value."""
+        df = pd.DataFrame(
+            {
+                "REQUIREMENTS_ATTRIBUTES_SECTION": ["Sec A", "Sec A", "Sec B"],
+                "REQUIREMENTS_ID": ["req1", "req2", "req3"],
+                "STATUS": ["PASS", "FAIL", "PASS"],
+                "CHECKID": ["c1", "c2", "c3"],
+                "REGION": ["-"] * 3,
+                "ACCOUNTID": ["123"] * 3,
+                "RESOURCEID": ["r1", "r2", "r3"],
+            }
+        )
+        result = get_section_containers_generic(
+            df, "REQUIREMENTS_ATTRIBUTES_SECTION", "REQUIREMENTS_ID"
+        )
+        assert len(result.children) == 2
+
+    def test_inner_title_includes_id_and_description(self):
+        """Inner accordion title is '<id> - <description>'."""
+        df = _df(
+            REQUIREMENTS_ATTRIBUTES_SECTION=["Sec A"],
+            REQUIREMENTS_DESCRIPTION=["Ensure MFA"],
+        )
+        rendered = str(
+            get_section_containers_generic(
+                df, "REQUIREMENTS_ATTRIBUTES_SECTION", "REQUIREMENTS_ID"
+            )
+        )
+        assert "req1 - Ensure MFA" in rendered
+
+    def test_arbitrary_ids_do_not_crash(self):
+        """Non-numeric ids are sorted lexicographically without raising."""
+        df = pd.DataFrame(
+            {
+                "REQUIREMENTS_ATTRIBUTES_SECTION": ["Sec A"] * 3,
+                "REQUIREMENTS_ID": ["AC-2(1)", "foo-bar", "step.1.2"],
+                "STATUS": ["PASS", "FAIL", "PASS"],
+                "CHECKID": ["c1", "c2", "c3"],
+                "REGION": ["-"] * 3,
+                "ACCOUNTID": ["123"] * 3,
+                "RESOURCEID": ["r1", "r2", "r3"],
+            }
+        )
+        result = get_section_containers_generic(
+            df, "REQUIREMENTS_ATTRIBUTES_SECTION", "REQUIREMENTS_ID"
+        )
+        tables = _datatable_column_ids(result)
+        assert tables and all("CHECKID" in cols for cols in tables)