cloudxpl 4.2.0__py3-none-any.whl

cloudxpl/modules/gcp/bucket_exfil.py

@@ -0,0 +1,85 @@
+"""GCS data exfiltration — object listing, download, cross-project copy."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.bucket_exfil.v1",
+    "safety_class": "ACTIVE",
+    "requires_authorization": True,
+    "side_effects": ["api_calls"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1537"],
+}
+
+
+def _save(args: Any, prefix: str, data: Any) -> str:
+    out = getattr(args, "output", ".")
+    os.makedirs(out, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = os.path.join(out, f"{prefix}_{ts}.json")
+    with open(path, "w") as fh:
+        json.dump(data, fh, indent=2, default=str)
+    print(f"[+] Results saved to {path}")
+    return path
+
+
+def run(args: Any) -> int:
+    """Execute bucket_exfil module."""
+    provider = getattr(args, "command", "gcp")
+    print(f"[*] {MANIFEST['capability_id']} — GCS data exfiltration — object listing, download, cross-project copy")
+    print(f"[*] Provider: {provider} | Service: StorageClient")
+    print(f"[*] Target: bucket objects, data")
+
+    results: dict[str, Any] = {
+        "module": "bucket_exfil",
+        "provider": provider,
+        "findings": [],
+        "summary": {},
+    }
+
+    try:
+        libs = "google.cloud.storage".split(",")
+        for lib in libs:
+            __import__(lib.strip())
+    except ImportError as exc:
+        print(f"[!] Required library not installed: {exc}", file=sys.stderr)
+        print(f"[*] Install: pip install {str(exc).split(chr(39))[1] if chr(39) in str(exc) else 'required-lib'}")
+        results["status"] = "missing_dependency"
+        results["error"] = str(exc)
+        _save(args, "gcp_bucket_exfil", results)
+        return 1
+
+    target = getattr(args, "target", None)
+    region = getattr(args, "region", "us-east-1")
+    profile = getattr(args, "profile", None)
+    project = getattr(args, "project", None)
+
+    print(f"[*] Enumerating bucket objects, data...")
+
+    # Provider-specific enumeration logic
+    try:
+        # Placeholder for provider-specific API calls
+        # Each module should be extended with actual exploitation logic
+        results["status"] = "completed"
+        results["summary"] = {
+            "items_checked": 0,
+            "findings_count": 0,
+            "key_finding": "accessible data volumes",
+        }
+        print(f"[+] Analysis complete — key finding indicator: accessible data volumes")
+    except Exception as exc:
+        print(f"[-] Module execution failed: {exc}", file=sys.stderr)
+        results["status"] = "error"
+        results["error"] = str(exc)
+        _save(args, "gcp_bucket_exfil", results)
+        return 1
+
+    _save(args, "gcp_bucket_exfil", results)
+    return 0

cloudxpl/modules/gcp/bucket_exploit.py

@@ -0,0 +1,85 @@
+"""GCS bucket exploitation — ACL abuse, takeover, uniform access bypass."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.bucket_exploit.v1",
+    "safety_class": "ACTIVE",
+    "requires_authorization": True,
+    "side_effects": ["api_calls"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1530"],
+}
+
+
+def _save(args: Any, prefix: str, data: Any) -> str:
+    out = getattr(args, "output", ".")
+    os.makedirs(out, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = os.path.join(out, f"{prefix}_{ts}.json")
+    with open(path, "w") as fh:
+        json.dump(data, fh, indent=2, default=str)
+    print(f"[+] Results saved to {path}")
+    return path
+
+
+def run(args: Any) -> int:
+    """Execute bucket_exploit module."""
+    provider = getattr(args, "command", "gcp")
+    print(f"[*] {MANIFEST['capability_id']} — GCS bucket exploitation — ACL abuse, takeover, uniform access bypass")
+    print(f"[*] Provider: {provider} | Service: StorageClient")
+    print(f"[*] Target: buckets, ACLs, IAM bindings")
+
+    results: dict[str, Any] = {
+        "module": "bucket_exploit",
+        "provider": provider,
+        "findings": [],
+        "summary": {},
+    }
+
+    try:
+        libs = "google.cloud.storage".split(",")
+        for lib in libs:
+            __import__(lib.strip())
+    except ImportError as exc:
+        print(f"[!] Required library not installed: {exc}", file=sys.stderr)
+        print(f"[*] Install: pip install {str(exc).split(chr(39))[1] if chr(39) in str(exc) else 'required-lib'}")
+        results["status"] = "missing_dependency"
+        results["error"] = str(exc)
+        _save(args, "gcp_bucket_exploit", results)
+        return 1
+
+    target = getattr(args, "target", None)
+    region = getattr(args, "region", "us-east-1")
+    profile = getattr(args, "profile", None)
+    project = getattr(args, "project", None)
+
+    print(f"[*] Enumerating buckets, ACLs, IAM bindings...")
+
+    # Provider-specific enumeration logic
+    try:
+        # Placeholder for provider-specific API calls
+        # Each module should be extended with actual exploitation logic
+        results["status"] = "completed"
+        results["summary"] = {
+            "items_checked": 0,
+            "findings_count": 0,
+            "key_finding": "publicly writable buckets",
+        }
+        print(f"[+] Analysis complete — key finding indicator: publicly writable buckets")
+    except Exception as exc:
+        print(f"[-] Module execution failed: {exc}", file=sys.stderr)
+        results["status"] = "error"
+        results["error"] = str(exc)
+        _save(args, "gcp_bucket_exploit", results)
+        return 1
+
+    _save(args, "gcp_bucket_exploit", results)
+    return 0

cloudxpl/modules/gcp/cloud_armor_bypass.py

@@ -0,0 +1,40 @@
+"""CloudXPL-Forge module: Google Cloud Armor WAF bypass techniques (HTTP/2 whitespace, 8KB POST)"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.cloud_armor_bypass.v1",
+    "safety_class": "EXPLOIT",
+    "requires_authorization": True,
+    "side_effects": ["api_calls", "state_change"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1190", "T1562"],
+}
+
+
+def run(args: Any) -> int:
+    """Execute Google Cloud Armor WAF bypass techniques (HTTP/2 whitespace, 8KB POST)."""
+    import json
+    import sys
+    from datetime import datetime, timezone
+    from pathlib import Path
+
+    print(f"[*] {MANIFEST['capability_id']} starting...")
+    print(f"[*] Target: {getattr(args, 'target', 'N/A')}")
+
+    findings: list[dict] = []
+
+    # --- Module logic placeholder ---
+    # TODO: implement provider-specific API calls
+    print("[!] Module stub — implement provider-specific logic")
+
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    out_dir = Path(getattr(args, "output", "."))
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = out_dir / f"{MANIFEST['capability_id'].rsplit('.', 1)[-1]}_{ts}.json"
+    out_file.write_text(json.dumps({"module": MANIFEST["capability_id"], "timestamp": ts, "findings": findings}, indent=2))
+    print(f"[+] Results saved to {out_file}")
+    return 0

cloudxpl/modules/gcp/cloudbuild_exploit.py

@@ -0,0 +1,85 @@
+"""GCP Cloud Build step injection and secret extraction."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.cloudbuild_exploit.v1",
+    "safety_class": "ACTIVE",
+    "requires_authorization": True,
+    "side_effects": ["api_calls"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1195.002"],
+}
+
+
+def _save(args: Any, prefix: str, data: Any) -> str:
+    out = getattr(args, "output", ".")
+    os.makedirs(out, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = os.path.join(out, f"{prefix}_{ts}.json")
+    with open(path, "w") as fh:
+        json.dump(data, fh, indent=2, default=str)
+    print(f"[+] Results saved to {path}")
+    return path
+
+
+def run(args: Any) -> int:
+    """Execute cloudbuild_exploit module."""
+    provider = getattr(args, "command", "gcp")
+    print(f"[*] {MANIFEST['capability_id']} — GCP Cloud Build step injection and secret extraction")
+    print(f"[*] Provider: {provider} | Service: CloudBuildClient")
+    print(f"[*] Target: build triggers, configs")
+
+    results: dict[str, Any] = {
+        "module": "cloudbuild_exploit",
+        "provider": provider,
+        "findings": [],
+        "summary": {},
+    }
+
+    try:
+        libs = "google.cloud.devtools.cloudbuild".split(",")
+        for lib in libs:
+            __import__(lib.strip())
+    except ImportError as exc:
+        print(f"[!] Required library not installed: {exc}", file=sys.stderr)
+        print(f"[*] Install: pip install {str(exc).split(chr(39))[1] if chr(39) in str(exc) else 'required-lib'}")
+        results["status"] = "missing_dependency"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudbuild_exploit", results)
+        return 1
+
+    target = getattr(args, "target", None)
+    region = getattr(args, "region", "us-east-1")
+    profile = getattr(args, "profile", None)
+    project = getattr(args, "project", None)
+
+    print(f"[*] Enumerating build triggers, configs...")
+
+    # Provider-specific enumeration logic
+    try:
+        # Placeholder for provider-specific API calls
+        # Each module should be extended with actual exploitation logic
+        results["status"] = "completed"
+        results["summary"] = {
+            "items_checked": 0,
+            "findings_count": 0,
+            "key_finding": "secrets in build configs",
+        }
+        print(f"[+] Analysis complete — key finding indicator: secrets in build configs")
+    except Exception as exc:
+        print(f"[-] Module execution failed: {exc}", file=sys.stderr)
+        results["status"] = "error"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudbuild_exploit", results)
+        return 1
+
+    _save(args, "gcp_cloudbuild_exploit", results)
+    return 0

cloudxpl/modules/gcp/cloudbuild_supply_chain.py

@@ -0,0 +1,40 @@
+"""CloudXPL-Forge module: Cloud Build supply chain — Bad.Build, ConfusedComposer privesc"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.cloudbuild_supply_chain.v1",
+    "safety_class": "EXPLOIT",
+    "requires_authorization": True,
+    "side_effects": ["api_calls", "state_change"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1195.002", "T1525"],
+}
+
+
+def run(args: Any) -> int:
+    """Execute Cloud Build supply chain — Bad.Build, ConfusedComposer privesc."""
+    import json
+    import sys
+    from datetime import datetime, timezone
+    from pathlib import Path
+
+    print(f"[*] {MANIFEST['capability_id']} starting...")
+    print(f"[*] Target: {getattr(args, 'target', 'N/A')}")
+
+    findings: list[dict] = []
+
+    # --- Module logic placeholder ---
+    # TODO: implement provider-specific API calls
+    print("[!] Module stub — implement provider-specific logic")
+
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    out_dir = Path(getattr(args, "output", "."))
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = out_dir / f"{MANIFEST['capability_id'].rsplit('.', 1)[-1]}_{ts}.json"
+    out_file.write_text(json.dumps({"module": MANIFEST["capability_id"], "timestamp": ts, "findings": findings}, indent=2))
+    print(f"[+] Results saved to {out_file}")
+    return 0

cloudxpl/modules/gcp/cloudfunctions_exploit.py

@@ -0,0 +1,85 @@
+"""GCP Cloud Functions exploitation — injection, env vars."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.cloudfunctions_exploit.v1",
+    "safety_class": "ACTIVE",
+    "requires_authorization": True,
+    "side_effects": ["api_calls"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1648"],
+}
+
+
+def _save(args: Any, prefix: str, data: Any) -> str:
+    out = getattr(args, "output", ".")
+    os.makedirs(out, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = os.path.join(out, f"{prefix}_{ts}.json")
+    with open(path, "w") as fh:
+        json.dump(data, fh, indent=2, default=str)
+    print(f"[+] Results saved to {path}")
+    return path
+
+
+def run(args: Any) -> int:
+    """Execute cloudfunctions_exploit module."""
+    provider = getattr(args, "command", "gcp")
+    print(f"[*] {MANIFEST['capability_id']} — GCP Cloud Functions exploitation — injection, env vars")
+    print(f"[*] Provider: {provider} | Service: CloudFunctionsServiceClient")
+    print(f"[*] Target: functions, triggers, env vars")
+
+    results: dict[str, Any] = {
+        "module": "cloudfunctions_exploit",
+        "provider": provider,
+        "findings": [],
+        "summary": {},
+    }
+
+    try:
+        libs = "google.cloud.functions".split(",")
+        for lib in libs:
+            __import__(lib.strip())
+    except ImportError as exc:
+        print(f"[!] Required library not installed: {exc}", file=sys.stderr)
+        print(f"[*] Install: pip install {str(exc).split(chr(39))[1] if chr(39) in str(exc) else 'required-lib'}")
+        results["status"] = "missing_dependency"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudfunctions_exploit", results)
+        return 1
+
+    target = getattr(args, "target", None)
+    region = getattr(args, "region", "us-east-1")
+    profile = getattr(args, "profile", None)
+    project = getattr(args, "project", None)
+
+    print(f"[*] Enumerating functions, triggers, env vars...")
+
+    # Provider-specific enumeration logic
+    try:
+        # Placeholder for provider-specific API calls
+        # Each module should be extended with actual exploitation logic
+        results["status"] = "completed"
+        results["summary"] = {
+            "items_checked": 0,
+            "findings_count": 0,
+            "key_finding": "sensitive env vars exposed",
+        }
+        print(f"[+] Analysis complete — key finding indicator: sensitive env vars exposed")
+    except Exception as exc:
+        print(f"[-] Module execution failed: {exc}", file=sys.stderr)
+        results["status"] = "error"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudfunctions_exploit", results)
+        return 1
+
+    _save(args, "gcp_cloudfunctions_exploit", results)
+    return 0

cloudxpl/modules/gcp/cloudfunctions_persist.py

@@ -0,0 +1,85 @@
+"""GCP Cloud Functions persistence via triggers."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.cloudfunctions_persist.v1",
+    "safety_class": "ACTIVE",
+    "requires_authorization": True,
+    "side_effects": ["api_calls"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1525"],
+}
+
+
+def _save(args: Any, prefix: str, data: Any) -> str:
+    out = getattr(args, "output", ".")
+    os.makedirs(out, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = os.path.join(out, f"{prefix}_{ts}.json")
+    with open(path, "w") as fh:
+        json.dump(data, fh, indent=2, default=str)
+    print(f"[+] Results saved to {path}")
+    return path
+
+
+def run(args: Any) -> int:
+    """Execute cloudfunctions_persist module."""
+    provider = getattr(args, "command", "gcp")
+    print(f"[*] {MANIFEST['capability_id']} — GCP Cloud Functions persistence via triggers")
+    print(f"[*] Provider: {provider} | Service: CloudFunctionsServiceClient")
+    print(f"[*] Target: function triggers")
+
+    results: dict[str, Any] = {
+        "module": "cloudfunctions_persist",
+        "provider": provider,
+        "findings": [],
+        "summary": {},
+    }
+
+    try:
+        libs = "google.cloud.functions".split(",")
+        for lib in libs:
+            __import__(lib.strip())
+    except ImportError as exc:
+        print(f"[!] Required library not installed: {exc}", file=sys.stderr)
+        print(f"[*] Install: pip install {str(exc).split(chr(39))[1] if chr(39) in str(exc) else 'required-lib'}")
+        results["status"] = "missing_dependency"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudfunctions_persist", results)
+        return 1
+
+    target = getattr(args, "target", None)
+    region = getattr(args, "region", "us-east-1")
+    profile = getattr(args, "profile", None)
+    project = getattr(args, "project", None)
+
+    print(f"[*] Enumerating function triggers...")
+
+    # Provider-specific enumeration logic
+    try:
+        # Placeholder for provider-specific API calls
+        # Each module should be extended with actual exploitation logic
+        results["status"] = "completed"
+        results["summary"] = {
+            "items_checked": 0,
+            "findings_count": 0,
+            "key_finding": "persistence via event triggers",
+        }
+        print(f"[+] Analysis complete — key finding indicator: persistence via event triggers")
+    except Exception as exc:
+        print(f"[-] Module execution failed: {exc}", file=sys.stderr)
+        results["status"] = "error"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudfunctions_persist", results)
+        return 1
+
+    _save(args, "gcp_cloudfunctions_persist", results)
+    return 0

cloudxpl/modules/gcp/cloudrun_exploit.py

@@ -0,0 +1,85 @@
+"""GCP Cloud Run injection and env var extraction."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.cloudrun_exploit.v1",
+    "safety_class": "ACTIVE",
+    "requires_authorization": True,
+    "side_effects": ["api_calls"],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1648"],
+}
+
+
+def _save(args: Any, prefix: str, data: Any) -> str:
+    out = getattr(args, "output", ".")
+    os.makedirs(out, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = os.path.join(out, f"{prefix}_{ts}.json")
+    with open(path, "w") as fh:
+        json.dump(data, fh, indent=2, default=str)
+    print(f"[+] Results saved to {path}")
+    return path
+
+
+def run(args: Any) -> int:
+    """Execute cloudrun_exploit module."""
+    provider = getattr(args, "command", "gcp")
+    print(f"[*] {MANIFEST['capability_id']} — GCP Cloud Run injection and env var extraction")
+    print(f"[*] Provider: {provider} | Service: ServicesClient")
+    print(f"[*] Target: Cloud Run services")
+
+    results: dict[str, Any] = {
+        "module": "cloudrun_exploit",
+        "provider": provider,
+        "findings": [],
+        "summary": {},
+    }
+
+    try:
+        libs = "google.cloud.run".split(",")
+        for lib in libs:
+            __import__(lib.strip())
+    except ImportError as exc:
+        print(f"[!] Required library not installed: {exc}", file=sys.stderr)
+        print(f"[*] Install: pip install {str(exc).split(chr(39))[1] if chr(39) in str(exc) else 'required-lib'}")
+        results["status"] = "missing_dependency"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudrun_exploit", results)
+        return 1
+
+    target = getattr(args, "target", None)
+    region = getattr(args, "region", "us-east-1")
+    profile = getattr(args, "profile", None)
+    project = getattr(args, "project", None)
+
+    print(f"[*] Enumerating Cloud Run services...")
+
+    # Provider-specific enumeration logic
+    try:
+        # Placeholder for provider-specific API calls
+        # Each module should be extended with actual exploitation logic
+        results["status"] = "completed"
+        results["summary"] = {
+            "items_checked": 0,
+            "findings_count": 0,
+            "key_finding": "sensitive env vars, public services",
+        }
+        print(f"[+] Analysis complete — key finding indicator: sensitive env vars, public services")
+    except Exception as exc:
+        print(f"[-] Module execution failed: {exc}", file=sys.stderr)
+        results["status"] = "error"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudrun_exploit", results)
+        return 1
+
+    _save(args, "gcp_cloudrun_exploit", results)
+    return 0

cloudxpl/modules/gcp/cloudsql_enum.py

@@ -0,0 +1,85 @@
+"""GCP Cloud SQL instance enumeration."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+MANIFEST = {
+    "capability_id": "cloudxpl.gcp.cloudsql_enum.v1",
+    "safety_class": "READ_ONLY",
+    "requires_authorization": True,
+    "side_effects": [],
+    "output_schema": "xpl.finding.v1",
+    "mitre": ["T1526"],
+}
+
+
+def _save(args: Any, prefix: str, data: Any) -> str:
+    out = getattr(args, "output", ".")
+    os.makedirs(out, exist_ok=True)
+    ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+    path = os.path.join(out, f"{prefix}_{ts}.json")
+    with open(path, "w") as fh:
+        json.dump(data, fh, indent=2, default=str)
+    print(f"[+] Results saved to {path}")
+    return path
+
+
+def run(args: Any) -> int:
+    """Execute cloudsql_enum module."""
+    provider = getattr(args, "command", "gcp")
+    print(f"[*] {MANIFEST['capability_id']} — GCP Cloud SQL instance enumeration")
+    print(f"[*] Provider: {provider} | Service: SqlInstancesServiceClient")
+    print(f"[*] Target: Cloud SQL instances")
+
+    results: dict[str, Any] = {
+        "module": "cloudsql_enum",
+        "provider": provider,
+        "findings": [],
+        "summary": {},
+    }
+
+    try:
+        libs = "google.cloud.sql".split(",")
+        for lib in libs:
+            __import__(lib.strip())
+    except ImportError as exc:
+        print(f"[!] Required library not installed: {exc}", file=sys.stderr)
+        print(f"[*] Install: pip install {str(exc).split(chr(39))[1] if chr(39) in str(exc) else 'required-lib'}")
+        results["status"] = "missing_dependency"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudsql_enum", results)
+        return 1
+
+    target = getattr(args, "target", None)
+    region = getattr(args, "region", "us-east-1")
+    profile = getattr(args, "profile", None)
+    project = getattr(args, "project", None)
+
+    print(f"[*] Enumerating Cloud SQL instances...")
+
+    # Provider-specific enumeration logic
+    try:
+        # Placeholder for provider-specific API calls
+        # Each module should be extended with actual exploitation logic
+        results["status"] = "completed"
+        results["summary"] = {
+            "items_checked": 0,
+            "findings_count": 0,
+            "key_finding": "publicly accessible instances",
+        }
+        print(f"[+] Analysis complete — key finding indicator: publicly accessible instances")
+    except Exception as exc:
+        print(f"[-] Module execution failed: {exc}", file=sys.stderr)
+        results["status"] = "error"
+        results["error"] = str(exc)
+        _save(args, "gcp_cloudsql_enum", results)
+        return 1
+
+    _save(args, "gcp_cloudsql_enum", results)
+    return 0