/

CVE-2026-41905

Severity:

HIGH RISK

(7.7)

SSRF in FreeScout URL Sanitization Helper

CVE-2026-41905

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal HTTP services via server-side requests

Severity:

HIGH RISK

(7.7)

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 FreeScout's Helper::sanitizeRemoteUrl() allows crafted URLs to bypass host validation after HTTP redirection.

When an attacker can provide a URL that passes the initial host checks, they can abuse redirects to make the FreeScout server initiate requests to internal HTTP services that should normally be inaccessible.

Affected context

The vulnerability occurs in FreeScout deployments that make outbound HTTP requests based on user-supplied URLs, using Helper::sanitizeRemoteUrl() for validation.

The helper correctly applies host checks to the original URL, but after following redirects via curlGetLastRedirectedUrl(), it fails to re-validate the final destination.

Environments where FreeScout can reach internal networks, metadata endpoints, or RFC1918 address ranges are more at risk, especially when those internal services accept simple HTTP requests without additional authentication.

Exploit preconditions

  • Attack surface: Any feature or integration in FreeScout that accepts user-supplied URLs and uses Helper::sanitizeRemoteUrl() before performing an HTTP request.
  • Required access: Ability to submit or control a URL parameter (e.g., through configuration, webhooks, integrations, or user-facing forms) that is processed by the sanitization helper.
  • Trigger point: The application follows HTTP redirects from the attacker-controlled URL and then uses the final URL as a request target without re-checking it against host restrictions.
  • Why exploitation is possible: Host validation is applied only to the initial URL, not the redirect chain, allowing an attacker to point the initial URL to an allowed host that redirects to a disallowed internal endpoint (e.g., cloud metadata, internal APIs, or RFC1918 IPs).

Why this happens

The root cause is a flawed URL validation workflow that does not account for the full redirect chain, mapping to CWE-918: Server-Side Request Forgery (SSRF).

Helper::sanitizeRemoteUrl() validates only the originally supplied URL against allowed/blocked hosts.

curlGetLastRedirectedUrl() then follows redirects, but the final destination is assumed to be safe without re-validation, creating a gap where the server can be tricked into making requests to internal resources that the initial host checks were meant to block.

Conceptually, this is an SSRF pattern where trust is placed in server-followed redirects without maintaining host-based security constraints along the entire request path.

Potential impact

  • The FreeScout server may send HTTP requests to internal APIs or services that are not directly exposed to the internet.
  • Attackers could query cloud instance metadata endpoints (e.g., for credentials or configuration) if reachable from the FreeScout host.
  • Internal network scanning may be possible by observing differences in server behavior or response timing when targeting various internal hosts.
  • Sensitive information from internal web interfaces could be retrieved if responses are surfaced, logged, or otherwise observable via the application.
  • Internal services might be abused as part of a broader pivot or reconnaissance phase in a larger compromise.

General mitigation guidance

Effective mitigation focuses on treating redirects as part of the untrusted input surface and enforcing consistent host validation across the entire request flow.

Some common defensive patterns include:

  • Re-validating the final URL after following redirects, applying the same host/IP allow/deny logic used for the initial URL.
  • Resolving and checking both hostnames and IP addresses against a denylist that covers RFC1918 ranges, link-local addresses, and cloud metadata endpoints.
  • Limiting outbound HTTP from the application host using network-layer controls (firewalls, security groups, egress proxies) so that internal networks and metadata services are not reachable by default.
  • Implementing strict allowlists for external hosts that FreeScout is permitted to contact, rather than relying solely on blocklists.
  • Treating user-supplied URLs as untrusted data and avoiding unnecessary server-side fetches where practical, or decoupling them via controlled proxy services.

How teams detect issues like this

Detection strategies generally align with identifying SSRF patterns and incomplete host validation around HTTP requests:

  • Static analysis: Search for helper functions that validate URLs (such as sanitizeRemoteUrl()) and confirm that their checks are applied after any redirect resolution; flag code where curl or HTTP clients follow redirects without post-redirect validation.
  • Code review: Examine call sites that perform outbound HTTP requests based on user-controlled input, checking for:
  • Absence of strict allowlists.
  • Missing IP range checks (e.g., private, loopback, link-local).
  • Logic that validates only the original URL but not the final redirect target.
  • Logging and monitoring: Instrument outbound HTTP requests to log destination hosts and IPs, then:
  • Alert on connections to internal IP ranges or unusual endpoints (e.g., metadata service IPs).
  • Correlate suspicious outbound requests with user actions or specific features.
  • Security testing: Use application security testing tools or manual testing to supply controlled URLs that redirect to known test endpoints in restricted ranges, verifying whether the application follows those redirects.

Sources

SourceLink
github.comgithub.com/freescout-help-desk/freescout/releases/tag/1.8.217
github.comgithub.com/freescout-help-desk/freescout/security/advisories/GHSA-22wf-848c-c856

Frequently asked

questions

Yes, if an external user or integration can supply URLs that FreeScout processes through the vulnerable helper and the server can reach internal or restricted endpoints, then remote exploitation is feasible.

The attacker needs the ability to provide or control a URL that is passed to Helper::sanitizeRemoteUrl() and subsequently requested by the server. This might come from user-facing configuration, integrations, or other input points where URLs are accepted.

The robust fix is to ensure that all final request destinations—after resolving redirects—are validated against strict host/IP allowlists or comprehensive deny rules, and to avoid making server-side requests to arbitrary user-supplied URLs where possible.

Adopt a defense-in-depth approach: enforce strong outbound network egress controls, centralize URL validation logic that runs after redirect resolution, rely on allowlists instead of blocklists, and include SSRF-specific checks in code review and automated security testing pipelines.

Find out what's already
exploitable in your codebase.