/

CVE-2026-41644

Severity:

HIGH RISK

(7.1)

SSRF in monetr Lunch Flow Integration

CVE-2026-41644

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-209, CWE-770, CWE-918

Impact:

Internal Network Access and Data Exposure via SSRF

Severity:

HIGH RISK

(7.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

A server-side request forgery (SSRF) flaw in monetr's Lunch Flow integration allows any authenticated user on a self-hosted instance to make the monetr server issue HTTP GET requests to attacker-controlled URLs.

Because responses from non-200 upstream requests are reflected back in API error messages, an attacker can abuse the server's network position to probe internal services and exfiltrate limited response data.

Affected context

This vulnerability affects self-hosted deployments of monetr that enable or expose the Lunch Flow integration endpoint to authenticated users.

The issue arises where backend logic accepts user-controlled URLs, performs outbound HTTP GET requests from the server's network environment, and then returns error details from non-200 responses directly in API error payloads.

Environments with internal services, metadata endpoints, or admin interfaces accessible only from the server network are at increased risk.

Exploit preconditions

  • Attack surface: HTTP API endpoint associated with Lunch Flow integration in a self-hosted monetr instance.
  • Required access: Any authenticated monetr user account on that instance.
  • Trigger point: Supplying a crafted or internal URL as the target for the Lunch Flow integration request.
  • Why exploitation is possible: The backend trusts user-supplied URLs, performs outbound HTTP GET requests on behalf of the user without strict allow-listing or network segmentation, and echoes non-200 response bodies back in error messages, enabling SSRF and response observation.

Why this happens

The core bug is a classic Server-Side Request Forgery (CWE-918) scenario: backend code accepts a user-provided URL and issues an HTTP request from the server environment without adequately constraining where that request may go.

This is compounded by insufficient control over error handling and verbosity (CWE-209: Information Exposure Through an Error Message), since response bodies from non-200 upstream calls are included in API error messages and returned to the caller.

Additionally, a lack of robust resource usage and outbound request controls (CWE-770: Allocation of Resources Without Limits or Throttling) can allow repeated probing of internal endpoints.

Abstractly, the insecure pattern is: "take user input as a URL, perform a server-side HTTP call, and surface detailed response content back to the user without validation, filtering, or network egress restrictions."

Potential impact

  • Could allow attackers to scan and probe internal network services reachable from the monetr server.
  • May expose response bodies from internal HTTP services, including status messages or sensitive metadata, via reflected API error messages.
  • Can enable access to cloud provider metadata endpoints or service discovery APIs, where network rules allow it.
  • Might facilitate pivoting toward other vulnerabilities on internal services by disclosing headers, error pages, or behavior differences.
  • Could contribute to denial-of-service or resource exhaustion by forcing the server to make large numbers of outbound requests.

General mitigation guidance

Effective mitigation focuses on constraining outbound requests and limiting information exposure:

  • Constrain destinations: Apply strict allow-lists for any URL or host that backend integrations are permitted to contact, and reject or normalize user-supplied URLs to that fixed set.
  • Harden URL validation: Remove user control over full URLs where possible; instead, expose fixed integration choices or identifiers that map to predefined endpoints on the server side.
  • Network-level controls: Use firewall rules, container network policies, and VPC controls to prevent application servers from reaching sensitive internal services or metadata endpoints.
  • Restrict error details: Avoid returning raw upstream response bodies in error messages; favor generic error codes and log detailed information server-side instead.
  • Limit resource usage: Apply timeouts, connection and request rate limits, and response size caps to all outbound HTTP calls initiated by the application.

How teams detect issues like this

Detection can combine code-level review with runtime monitoring:

  • Static analysis: Search for HTTP client usage where URLs are derived directly or indirectly from user input, especially in integration or webhook-like endpoints. Flag patterns that concatenate or pass unvalidated URLs.
  • Code review cues: Look for features that allow users to configure arbitrary endpoints, webhooks, or callback URLs, and verify that destination validation, allow-listing, and error sanitization are in place.
  • Security testing: Use dynamic testing to send internal-looking hostnames or IPs (e.g., 127.0.0.1, link-local IPs, metadata service addresses) through candidate endpoints and observe whether responses or timing behaviors indicate SSRF.
  • Monitoring and logging: Track outbound HTTP requests from the application, alert on requests to unexpected internal ranges or unusual domains, and correlate spikes with specific API calls or user accounts.

Sources

SourceLink
github.comgithub.com/monetr/monetr/commit/c260caa3c573a4a396ec2d264c7641a5d958385b
github.comgithub.com/monetr/monetr/pull/3122
github.comgithub.com/monetr/monetr/releases/tag/v1.12.5
github.comgithub.com/monetr/monetr/security/advisories/GHSA-29v9-frvh-c426

Frequently asked

questions

Yes, in the sense that any authenticated user of a self-hosted monetr instance can exploit it remotely via the application API, but they must first have valid credentials on that instance. It is not exploitable by completely unauthenticated, anonymous users.

The attacker needs authenticated access to the affected Lunch Flow integration functionality within a self-hosted monetr deployment. They do not need administrative privileges; a regular user account capable of triggering the integration is sufficient.

The most robust fix is to prevent arbitrary user-controlled URLs from being used directly in server-side HTTP requests. Instead, use fixed, server-defined endpoints (or tightly validated allow-lists) and avoid returning raw upstream responses in API errors.

Treat outbound requests as a sensitive resource: require strict URL validation and allow-lists, implement network egress controls, minimize error detail exposed to users, and include SSRF checks in code review and automated security testing for any feature that contacts external services.

Find out what's already
exploitable in your codebase.