/

CVE-2024-26477

Severity:

HIGH RISK

(7.5)

Information Exposure in Statping-ng Monitoring Endpoints

CVE-2024-26477

Analyzed

Vulnerability type

Category:

Information Exposure

CWE:

CWE-200

Impact:

Sensitive Information Disclosure

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

Statping-ng 0.91.0 exposes sensitive information when the api parameter is crafted and sent to specific HTTP endpoints.

An attacker who can reach the oauth, amazon_sns, or export endpoints may be able to retrieve confidential data that should not be returned in API responses.

Affected context

This vulnerability affects Statping-ng instances running version 0.91.0 where the oauth, amazon_sns, or export HTTP endpoints are reachable (e.g., from the internet or an internal network).

The issue occurs in the handling of the api parameter, which is processed in a way that can cause internal or confidential information to be included in the response.

The risk increases when these endpoints are exposed without additional network-layer protections or strict access controls.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints /oauth, /amazon_sns, and /export (or their configured routes) on a Statping-ng 0.91.0 instance.
  • Required access: Ability to send crafted HTTP requests to the vulnerable endpoints; no special privileges implied beyond network reachability unless deployments add their own access controls.
  • Trigger point: Supplying specific values to the api parameter in requests to the affected endpoints.
  • Why exploitation is possible: Input from the api parameter is trusted and used in logic that influences what data is returned, without sufficient validation, filtering, or authorization checks to prevent exposure of sensitive information.

Why this happens

The root cause aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor.

The application logic behind the oauth, amazon_sns, and export endpoints relies on the api parameter in a way that can cause data intended for internal use or authorized users to be returned to the requester.

This typically stems from missing or incomplete authorization checks, overly broad response construction, or failure to constrain which resources can be referenced or enumerated through user-controlled parameters.

As a result, the system breaks the principle of least privilege by allowing untrusted requests to influence which internal data is exposed.

Potential impact

  • Exposure of configuration details related to OAuth, notification, or export mechanisms.
  • Disclosure of API keys, tokens, callback URLs, or integration identifiers, if these are included in the responses.
  • Leak of monitoring or service metadata that could assist in further attacks (e.g., service names, health checks, internal endpoints).
  • Indirect exposure of user-related or organization-specific operational information handled by Statping-ng.

General mitigation guidance

Effective mitigation focuses on tightening data exposure paths and enforcing strict access control around sensitive endpoints and parameters:

  • Treat the api parameter and similar fields as untrusted input and restrict them to a well-defined set of allowed values or resources.
  • Apply strict authorization checks before returning any configuration, integration, or export-related data, ensuring only authenticated and appropriately authorized users can access it.
  • Implement response hardening so that sensitive fields (tokens, secrets, internal URLs) are never returned from public or semi-public endpoints.
  • Follow the principle of least privilege when designing API responses, returning only the minimal data required for the client's function.
  • Consider segmenting administrative or configuration APIs onto separate paths, hosts, or networks that are not directly internet-exposed.

How teams detect issues like this

Organizations can detect and monitor for this class of issue using a mix of code and runtime analysis:

  • Static analysis and code review: Look for handlers on oauth, amazon_sns, export, and similar endpoints where user-controlled parameters such as api directly influence which records, files, or configuration objects are returned.
  • Security-focused review: Verify that sensitive data structures (e.g., credentials, tokens, secrets, internal topology) are never serialized into responses without explicit authorization checks.
  • Dynamic testing: Use automated or manual API testing tools to fuzz query parameters (including api) and observe whether responses contain configuration, secrets, or other unexpected information.
  • Logging and monitoring: Log access to sensitive endpoints and include metadata about unusual query parameter values; alert on abnormal patterns indicative of enumeration or probing.

Sources

SourceLink
github.comgithub.com/Ev3rR3d/Statping_Poc
github.comgithub.com/Ev3rR3d/Statping_Poc/tree/main/CVE-2024-26477
github.comgithub.com/statping-ng/statping-ng
statping-ng.github.iostatping-ng.github.io/

Frequently asked

questions

Yes, if the affected Statping-ng endpoints are reachable over the network (for example, exposed to the internet or accessible within an internal network), an attacker can attempt to exploit the issue by sending crafted requests.

The description does not require authentication, so it should be treated as potentially exploitable without login unless the specific deployment has added its own access controls in front of these endpoints.

Apply strict authorization checks before returning any sensitive data and limit the api parameter to a controlled set of allowed values.

Additionally, ensure that secrets, tokens, and internal configuration details are never exposed in standard API responses.

Design APIs with a "deny by default" mindset: expose only minimal necessary data, validate and constrain user-controlled parameters, enforce robust access control on configuration and export endpoints, and regularly review responses for unintended sensitive fields.

Find out what's already
exploitable in your codebase.