/

CVE-2025-60949

Severity:

CRITICAL RISK

(9.1)

Information Exposure in Census CSWeb app/config Endpoint

CVE-2025-60949

Analyzed

Vulnerability type

Category:

Information Exposure

CWE:

CWE-200

Impact:

Exposure of Sensitive Configuration and Secrets

Severity:

CRITICAL RISK

(9.1)

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

Census CSWeb 8.0.1 can expose its app/config directory over HTTP in certain deployments, allowing configuration files to be retrieved directly by anyone on the network.

A remote, unauthenticated attacker may request these files and obtain leaked secrets such as credentials, keys, or other sensitive settings, which can in turn enable further compromise.

Affected context

The vulnerability affects Census CSWeb 8.0.1 deployments where the app/config path is accessible over HTTP/S from untrusted networks.

This typically occurs when default or permissive web server routing is used and configuration directories are not explicitly protected.

In these cases, configuration files under app/config may be served as static content instead of being restricted to the application runtime.

Exploit preconditions

  • Attack surface: HTTP/S interface of the Census CSWeb application.
  • Required access: None; exploitation can occur without authentication if the instance is reachable over the network.
  • Trigger point: Direct HTTP requests sent to paths under app/config (e.g., requesting configuration files by name).
  • Why exploitation is possible: The configuration directory is mapped into the web-accessible path without appropriate access controls or filtering, allowing the server to return sensitive configuration files as regular responses.

Why this happens

This issue stems from improper access control and information handling around configuration files.

The app/config directory, which is intended for internal use by the application, is exposed as part of the web server's document root or routing configuration.

As a result, sensitive configuration files are treated as static resources instead of protected assets, leading to CWE-200: Exposure of Sensitive Information.

Conceptually, this reflects a design pattern where confidential configuration and secrets are stored in locations that are not clearly segregated from public web content, and no additional authorization checks are enforced before serving them.

Potential impact

  • Leakage of database connection strings, passwords, API keys, or encryption keys.
  • Disclosure of internal service endpoints and infrastructure details that can aid further attacks.
  • Facilitation of account takeover, data exfiltration, or privilege escalation using exposed credentials.
  • Easier lateral movement within the environment by abusing revealed secrets and configuration details.
  • Loss of confidentiality for application-specific business logic or operational parameters.

General mitigation guidance

Mitigation typically focuses on preventing configuration files and secrets from being directly web-accessible and reducing the sensitivity of any data exposed through configuration.

Recommended defensive patterns include:

  • Segregating configuration and secret storage from the web server document root and publicly routable paths.
  • Applying explicit deny rules or access controls (e.g., HTTP server configuration, reverse proxy rules) to block direct access to configuration directories.
  • Using environment variables, dedicated secret stores, or configuration services for credentials and keys instead of embedding them in web-served files.
  • Minimizing the amount of sensitive information in configuration files and rotating any secrets that might have been exposed.
  • Adopting a least-privilege model for credentials used by the application so that any leaked secrets have limited blast radius.

How teams detect issues like this

Detection can combine configuration review, automated scanning, and monitoring:

  • Configuration review: Examine web server and application routing configuration to ensure internal directories like app/config are not part of the public document root or accessible routes.
  • Automated scanning: Use web vulnerability scanners or custom scripts to crawl the application and attempt to fetch known configuration paths and file patterns, flagging successful retrievals.
  • Static analysis / policy checks: Enforce infrastructure-as-code and deployment policies that prohibit mounting configuration directories into publicly exposed paths.
  • Logging and monitoring: Monitor HTTP access logs for suspicious requests targeting configuration-like paths (e.g., /app/config/, .env, YAML/JSON configuration files) and alert on successful responses.
  • Code and architecture review: During development and deployment pipeline reviews, assess separation between configuration storage and public web content.

Sources

SourceLink
github.comgithub.com/csprousers/csweb/commit/eba0b59a243390a1a4f9524cce6dbc0314bf0d91
github.comgithub.com/hx381/cspro-exploits
raw.githubusercontent.comraw.githubusercontent.com/cisagov/CSAF/develop/csaf_files/IT/white/2026/va-26-082-01.json
cve.orgcve.org/CVERecord?id=CVE-2025-60949

Frequently asked

questions

Yes. If the Census CSWeb instance is exposed over the internet or any untrusted network and app/config is reachable, an attacker anywhere on that network can attempt to retrieve configuration files without prior access.

No. The weakness occurs before any authentication controls are applied. An unauthenticated attacker can send direct HTTP requests to the exposed app/config path and receive responses if the directory is publicly accessible.

The safest pattern is to ensure that sensitive configuration directories are never mapped to public web paths, combined with strict HTTP server rules that explicitly deny access to internal directories.

Additionally, moving secrets out of on-disk, web-adjacent configuration files into dedicated secret management solutions significantly reduces exposure risk.

Future deployments can be hardened by adopting secure-by-default web server templates that exclude configuration and internal directories from the document root, enforcing infrastructure-as-code policies that validate directory exposure, and routinely scanning applications for accessible configuration paths.

Incorporating threat modeling around configuration and secret storage into the design phase helps ensure that sensitive assets remain isolated from public interfaces.

Find out what's already
exploitable in your codebase.