/

CVE-2026-35185

Severity:

HIGH RISK

(7.5)

Improper Access Control in HAX CMS

CVE-2026-35185

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-284, CWE-522, CWE-532

Impact:

Sensitive Information Exposure and Session/Account Compromise

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

HAX CMS exposes a /server-status endpoint that is publicly accessible and leaks sensitive data such as authentication tokens, client IP addresses, and server configuration details.

An unauthenticated attacker can passively monitor real-time user interactions and harvest internal infrastructure information, increasing the risk of account compromise and targeted attacks.

Affected context

This vulnerability impacts HAX CMS deployments running versions prior to 25.0.0 with the /server-status endpoint enabled and reachable from untrusted networks (e.g., the public internet).

It manifests when operational or diagnostic status pages are deployed without authentication or network-level restrictions, allowing anyone who can reach the endpoint to view runtime data, user-related metadata, and configuration details.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the HAX CMS instance, specifically the /server-status endpoint
  • Required access: None; exploitable by any unauthenticated client who can send requests to the endpoint
  • Trigger point: A simple HTTP request (e.g., GET) to /server-status while the application is running
  • Why exploitation is possible: The status endpoint is exposed without proper access controls, authentication, or redaction of sensitive values, allowing direct retrieval of operational telemetry and secrets-like data

Why this happens

The core issue is an improper access control design around an operational status endpoint.

A diagnostic interface that surfaces sensitive runtime data (including user_token values, user activity traces, client IP addresses, and server configuration details) is exposed without authentication or authorization checks, corresponding to CWE-284: Improper Access Control.

Compounding this, sensitive tokens and configuration details are transmitted and logged in a way that makes them visible to any requester (CWE-522: Insufficiently Protected Credentials and CWE-532: Insertion of Sensitive Information into Log Files).

Conceptually, a privileged observability/debug interface is treated like a public resource, breaking the assumption that internal telemetry and secrets should only be accessible to trusted operators and services.

Potential impact

  • Attackers may harvest authentication tokens (user_token) that could be used to impersonate users or hijack active sessions.
  • Adversaries can monitor real-time user interactions, aiding in targeted phishing, social engineering, or reconnaissance.
  • Exposure of client IP addresses can assist in profiling users and mapping network topologies.
  • Disclosure of server configuration details can aid in further exploitation, such as identifying framework versions, enabled modules, and misconfigurations.
  • Increased risk of lateral movement due to leaked internal infrastructure information that informs subsequent attacks.

General mitigation guidance

Effective mitigation centers on treating operational status interfaces as sensitive, privileged surfaces by default.

Common defensive patterns include:

  • Requiring strong authentication and authorization for status, debug, and admin endpoints, limiting access to operators and automated monitoring systems.
  • Restricting access to such endpoints at the network layer (e.g., binding to localhost, using VPNs, or IP allowlists).
  • Minimizing sensitive data in status output: avoid including tokens, raw credentials, or detailed configuration secrets; redact or aggregate where possible.
  • Applying the principle of least privilege to how runtime telemetry is exposed, ensuring only the minimal information needed for health monitoring is available.
  • Implementing a secure configuration baseline where new diagnostic endpoints are disabled or locked down by default and must be explicitly enabled.

How teams detect issues like this

High-level detection approaches typically involve:

  • Reviewing routing and controller definitions for status, metrics, or debug endpoints that lack authentication or access control middleware.
  • Using static analysis or configuration-linting rules to flag endpoints with sensitive keywords (e.g., "status", "debug", "admin") that are not protected by an authorization layer.
  • Conducting security-focused code review to identify places where tokens, credentials, or configuration values are rendered into responses or logs.
  • Employing automated application security testing tools (DAST) to crawl and enumerate unprotected endpoints that expose operational data.
  • Defining security policies that prevent deployment if public routes expose sensitive headers, tokens, or infrastructure details, enforced via CI/CD gates.

Sources

SourceLink
github.comgithub.com/haxtheweb/issues/security/advisories/GHSA-3676-wj6r-hwh7

Frequently asked

questions

Yes. Anyone who can reach the /server-status endpoint over the network can exploit this issue, without needing valid credentials, as long as the endpoint is exposed and not restricted by firewalls or access controls.

The attacker only needs basic network access to the HAX CMS instance—no authentication is required. The risk is highest when the instance is directly accessible from the public internet.

The safest pattern is to treat the status endpoint as a privileged administrative interface: require authentication and authorization, limit network exposure, and remove or redact sensitive fields (such as tokens and configuration secrets) from all status output.

Adopt secure-by-default practices for observability endpoints, including mandatory access control, network scoping, and strict review of which data is exposed; integrate automated checks in CI/CD to flag new endpoints that return sensitive information or lack proper protection.

Find out what's already
exploitable in your codebase.