CVE-2026-57443: Unauthenticated Operations API Information Disclosure in SCBE-AETHERMOORE

The SCBE-AETHERMOORE framework is a geometric AI governance and evaluation platform. To facilitate system monitoring and administrative tasks, the application deploys an API server, designated as api_server.py, which hosts the AetherBrowser management interface. This server exposes multiple utility routes intended for operational support, system diagnostics, and command-line interface automation.

A critical security flaw exists in the routing architecture of this API server. The /api/ops/check-email endpoint does not implement any access control or identity validation mechanisms, corresponding to CWE-306 (Missing Authentication for Critical Function). Because the framework is designed to run in diverse, sometimes highly permissive environments, this unauthenticated exposure creates a significant attack surface.

An unauthenticated remote attacker can query the endpoint directly over the network to invoke local system actions and extract sensitive information. Specifically, the route triggers a background synchronization routine that logs into configured operator mailboxes and returns raw message metadata. The lack of network isolation combined with permissive default configurations increases the overall exposure of the system.

The technical root cause resides in the declaration of administrative endpoints under the /api/ops/ and /api/cli/ routing namespaces within scripts/aetherbrowser/api_server.py. In standard web architectures, sensitive operations are protected by authentication dependencies, such as FastAPI's Depends injection or custom middleware wrappers. The developer omitted these guards on administrative routes, allowing direct HTTP invocation.

Upon receiving an HTTP POST request at /api/ops/check-email, the API server invokes an external Python subprocess. It locates the email_reader.py script and executes it utilizing sys.executable within a separate thread using asyncio.to_thread. This subprocess is designed to query internal environmental variables to retrieve saved IMAP credentials, establish a network connection to target email providers, and index recent administrative communications.

The core architectural flaw is exacerbated by two secondary configuration vulnerabilities. First, the FastAPI instance binds to the wildcard address 0.0.0.0, rendering the management utility accessible on all physical and virtual network interfaces of the host system. Second, the CORS middleware is configured to accept requests from any origin (allow_origins=["*"]) and allow credentials, enabling cross-origin browser requests to query localhost or local network resources.

To fully understand the vulnerability, it is necessary to examine the original routing implementation in scripts/aetherbrowser/api_server.py. The endpoint was declared directly as a standard route without any middleware, routing decorators, or security dependencies.

# Vulnerable routing structure in scripts/aetherbrowser/api_server.py
@app.post("/api/ops/check-email")
async def ops_check_email():
    """Run the Apollo email reader and return classified digests."""
    script = ROOT / "scripts" / "apollo" / "email_reader.py"
    if not script.exists():
        return {"error": "email_reader.py not found", "digests": []}
 
    # Subprocess run in thread context without authorization check
    result = await asyncio.to_thread(
        _run_subprocess,
        [sys.executable, str(script)],
        timeout=30,
    )
    return {
        "output": result.get("stdout", "")[:2000],
        "exit_code": result.get("exit_code", -1),
        "errors": result.get("stderr", "")[:500] if result.get("stderr") else None,
    }

The vulnerable code executes _run_subprocess on email_reader.py and blindly slices the standard output to returning the first 2000 characters to the caller. This stdout contains raw text captured during IMAP collection, which routinely includes sensitive authentication tokens, password reset links, and operational details.

# Patched authentication implementation using HTTP middleware
_OPERATOR_PREFIXES = ("/api/ops/", "/api/cli/")
 
@app.middleware("http")
async def _guard_operator_endpoints(request: Request, call_next):
    if request.method != "OPTIONS" and any(request.url.path.startswith(p) for p in _OPERATOR_PREFIXES):
        token = (
            os.environ.get("SCBE_OPS_ADMIN_TOKEN", "").strip()
            or os.environ.get("SCBE_RUNTIME_GATE_ADMIN_TOKEN", "").strip()
        )
        if not token:
            return JSONResponse(
                {"detail": "operator endpoints disabled (set SCBE_OPS_ADMIN_TOKEN to enable)"},
                status_code=403,
            )
        if not hmac.compare_digest(request.headers.get("x-admin-token", ""), token):
            return JSONResponse({"detail": "invalid or missing X-Admin-Token"}, status_code=401)
    return await call_next(request)

The patch introduces a robust, fail-closed HTTP middleware handler named _guard_operator_endpoints. This middleware intercepts all incoming HTTP requests targeting /api/ops/ or /api/cli/ prefixes. If no admin token is configured in the environment (SCBE_OPS_ADMIN_TOKEN or SCBE_RUNTIME_GATE_ADMIN_TOKEN), the middleware returns an HTTP 403 Forbidden status, effectively disabling the endpoints. If a token is configured, the middleware validates the client-supplied X-Admin-Token header using hmac.compare_digest to prevent timing attacks.

Exploitation of CVE-2026-57443 does not require complex payloads or specialized toolsets. An attacker only needs network access to the API port (default 8100) to trigger the vulnerability. Because the endpoint does not validate request bodies, a basic empty JSON payload or standard raw POST request is sufficient to trigger the back-end script.

The first vector involves direct external network scanning. An attacker identifies an internet-exposed instance of SCBE-AETHERMOORE and issues a standard HTTP POST request to /api/ops/check-email. The server handles the request, initiates the IMAP session, reads the target operator's mailbox, and returns the compiled email digests directly in the HTTP response body.

The second, more subtle vector involves Cross-Origin Resource Sharing (CORS) abuse. An attacker can host a malicious script on an external website. When a legitimate operator visits this website while running SCBE-AETHERMOORE locally, the script initiates a silent fetch request to http://localhost:8100/api/ops/check-email. Since the CORS policy allows all origins, the browser permits the script to read the response and exfiltrate private email data to the attacker's server.

The impact of this vulnerability is classified as High, primarily affecting confidentiality. Successful exploitation exposes sensitive operator emails, which may contain API keys, configuration credentials, deployment tokens, and private operational data. This information can be leveraged by an attacker to compromise broader systems or conduct highly targeted social engineering attacks.

The CVSS v3.1 score of 7.5 reflects the critical nature of the exposure. Because no authentication is required and the attack complexity is low, any system exposed to the network is highly vulnerable. The lack of integrity and availability impact limits the score to 7.5, but the resulting data exposure often serves as an initial access vector for subsequent phases of an intrusion.

The risk is magnified in environments where the framework runs with high privileges or within isolated corporate networks. If an attacker leverages the CORS exploitation path, they can bypass network firewalls entirely, utilizing the victim's own web browser to bridge the gap between the internet and the internal management API.

Remediation requires updating the SCBE-AETHERMOORE framework to version 4.2.1 or later. This version introduces the middleware protection layer that disables operator endpoints by default unless explicitly enabled via environmental configuration. Administrators should audit their current deployment configurations to ensure the patch is successfully applied.

To configure the patched system securely, administrators must set a cryptographically secure token in the SCBE_OPS_ADMIN_TOKEN environment variable. This token must be passed in the X-Admin-Token HTTP header for all legitimate administrative requests. If the token is not set, the endpoints remain safely disabled, preventing any unauthenticated interaction.

In addition to software updates, network-level mitigations should be implemented. Administrators should configure the API server to bind exclusively to localhost (127.0.0.1) rather than the wildcard 0.0.0.0. Implementing firewalls or reverse proxies to restrict access to port 8100 ensures that only authorized network segments can communicate with the administrative API.