/

CVE-2025-50199

Severity:

CRITICAL RISK

(9.1)

SSRF in Chamilo LMS OpenID Endpoint

CVE-2025-50199

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Potential Data Exfiltration via SSRF

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

Chamilo LMS contains a blind server-side request forgery (SSRF) issue where the openid_url POST parameter in /index.php can be abused to make arbitrary outbound HTTP requests from the server.

An attacker who can submit crafted OpenID URLs may be able to pivot through the Chamilo server to access internal services or cloud metadata endpoints that are not directly exposed to the internet.

Affected context

The vulnerability occurs in deployments of Chamilo LMS that:

  • Expose /index.php to users (typically the main application entry point)
  • Accept an openid_url parameter via HTTP POST as part of OpenID-related functionality
  • Allow the application server to initiate outbound HTTP/HTTPS connections without strict egress controls

It becomes especially risky in environments where the Chamilo server can reach internal-only web services, databases with HTTP APIs, or cloud provider metadata endpoints.

Exploit preconditions

  • Attack surface: HTTP POST requests to /index.php with control over the openid_url parameter
  • Required access: Ability to send authenticated or unauthenticated web requests to the Chamilo instance, depending on how OpenID functionality is exposed
  • Trigger point: Application logic that processes openid_url by initiating outbound HTTP requests from the server
  • Why exploitation is possible: The application uses attacker-controlled URLs for server-side HTTP requests without sufficient validation, allow-listing, or restriction of reachable destinations, leading to SSRF. The behavior is blind because the attacker may not see the full response, but can infer effects via side channels (timing, error messages, or observable state changes).

Why this happens

This issue stems from treating user-supplied URLs as trustworthy targets for server-side HTTP calls.

When the openid_url POST parameter is used directly or with minimal validation to construct outbound requests, an attacker can point the server at arbitrary endpoints, including internal network resources. This maps to CWE-918: Server-Side Request Forgery (SSRF), where the server is tricked into acting as an unintended HTTP client and network pivot. Insufficient normalization, host/IP validation, and lack of destination restrictions make this misuse possible.

Potential impact

  • Access to internal HTTP services that are otherwise not exposed to the public internet
  • Interaction with cloud provider metadata services, which can lead to leakage of credentials or tokens
  • Network reconnaissance of internal infrastructure (port scanning via response behaviors or timing)
  • Potential exploitation of internal applications by sending crafted requests from the Chamilo server
  • Bypassing IP-based access controls that trust traffic originating from the Chamilo host or network
  • Indirect data exfiltration through responses or side channels, depending on how responses are processed

General mitigation guidance

Effective mitigation focuses on constraining where server-initiated requests can go and reducing trust in user-provided URLs:

  • Avoid making direct server-side HTTP requests using unvalidated, user-supplied URLs; prefer fixed or configuration-driven endpoints when integrating identity providers.
  • Introduce strict allow-lists of trusted OpenID or identity provider domains and enforce exact or well-defined matches (including scheme, host, and port).
  • Normalize and parse URLs securely, then validate hosts against allow-lists rather than relying on string operations.
  • Block access to link-local, loopback, and private IP ranges (e.g., 127.0.0.0/8, 10.0.0.0/8) and special endpoints such as cloud metadata IPs.
  • Apply network-level egress controls so the Chamilo server can only reach required external services.
  • Run the application with least-privilege network access and avoid granting broad internal connectivity when it is not strictly needed.

How teams detect issues like this

Organizations can detect and monitor SSRF risk using a combination of code and operational signals:

  • Static analysis and code review:
  • Flag server-side HTTP calls (e.g., cURL, HTTP client libraries) that use request parameters like openid_url directly.
  • Look for URL construction logic that lacks allow-list checks, IP range filtering, or scheme validation.
  • Review authentication and SSO/OpenID flows specifically, as they often involve external URL handling.
  • Security testing:
  • Include SSRF test cases in application security testing, probing parameters that accept URLs for unintended internal access.
  • Use dynamic analysis tools or fuzzers to automatically exercise URL-based parameters.
  • Runtime monitoring:
  • Log and monitor outbound HTTP requests from the Chamilo server, especially to internal IP ranges or unusual external hosts.
  • Implement alerting for attempts to access known sensitive endpoints (e.g., cloud metadata addresses, localhost).

Automated application security tools and CI-integrated linters can help enforce policies around safe URL handling and identify SSRF patterns early in development.

Sources

SourceLink
github.comgithub.com/chamilo/chamilo-lms/releases/tag/v1.11.30
github.comgithub.com/chamilo/chamilo-lms/security/advisories/GHSA-jv2w-m5r6-p52h

Frequently asked

questions

Yes. In typical deployments, any user who can reach the Chamilo /index.php endpoint and provide an openid_url value may be able to trigger SSRF, subject to authentication and feature exposure.

The attacker must be able to send HTTP POST requests to the affected endpoint with control over the openid_url parameter. Whether they must be authenticated depends on how the OpenID feature is configured, but the vulnerability does not inherently require elevated privileges.

The most robust pattern is to avoid using arbitrary user-supplied URLs as outbound request targets. Instead, maintain a fixed set of trusted OpenID provider endpoints, validate inputs against this allow-list, and block requests to private or internal address spaces at both application and network layers.

Treat any user-controlled URL or host input as untrusted; design features so that servers only connect to pre-approved destinations, enforce strict URL and IP validation, and add network egress controls. Incorporating SSRF-specific checks into code review, threat modeling, and automated security testing helps catch these patterns before deployment.

Find out what's already
exploitable in your codebase.