/

CVE-2026-32133

Severity:

CRITICAL RISK

(9.1)

Server-Side Request Forgery (SSRF) in 2FAuth

CVE-2026-32133

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized Network Access to Internal/Metadata Services

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

A blind Server-Side Request Forgery (SSRF) flaw in 2FAuth allows authenticated users to coerce the server into making arbitrary HTTP requests, including to internal network resources and cloud metadata services.

The image parameter in OTP URLs is not sufficiently restricted, so requests are issued to attacker-controlled URLs before any validation, exposing internal services to probing and potential abuse.

Affected context

This vulnerability occurs in 2FAuth when users add or manage OTP (One-Time Password) entries that include an image URL parameter.

The application fetches the remote image from the supplied URL using the server's network context.

Because the target URL is not properly filtered for internal or special-purpose IP ranges before the request is dispatched, the server can be used as a proxy to reach internal services, private network segments, or cloud provider metadata endpoints.

Exploit preconditions

  • Attack surface: HTTP endpoint(s) that accept OTP or account configuration data including an image or icon URL parameter.
  • Required access: Authenticated user ability to create or modify 2FA entries with a custom image URL.
  • Trigger point: Submitting or updating an OTP URL containing a crafted image parameter that points to internal IPs, hostnames, or metadata services.
  • Why exploitation is possible: URL validation is performed only after the HTTP request is made and focuses on the response (e.g., checking for valid image content) rather than preventing outbound requests to sensitive address ranges in the first place.

Why this happens

The underlying issue is a classic Server-Side Request Forgery pattern mapped to CWE-918, where untrusted user input is used as the target of server-initiated HTTP requests.

In this case, the image parameter within OTP URLs is treated as a trusted remote resource location.

The application performs outbound HTTP requests using server privileges and network positioning without:

  • Enforcing strict allowlists (e.g., public domains only),
  • Blocking internal or link-local address ranges,
  • Or performing canonicalization and re-checking of redirects.

Even though response validation was added to filter what gets stored, the unsafe behavior occurs at the earlier stage when the request is first issued, leaving the server vulnerable to being leveraged as an internal network probe.

Potential impact

  • Discovery and enumeration of internal services and network topology.
  • Access to cloud provider metadata endpoints, which may expose credentials or instance configuration.
  • Interaction with internal HTTP-based admin panels or management APIs that are not directly exposed to the internet.
  • Use of the application server as a pivot point for further attacks inside the private network.
  • Potential exfiltration of sensitive internal information via timed or side-channel responses (blind SSRF).

General mitigation guidance

Effective mitigation centers on constraining where the server is allowed to connect and demoting trust in user-supplied URLs:

  • Apply strict network-layer egress controls so application servers cannot reach internal segments or metadata addresses except where explicitly needed.
  • Implement URL allowlisting for remote resources (e.g., only specific domains or CDNs) and reject arbitrary hostnames or IP addresses.
  • Deny requests to internal, loopback, link-local, and metadata IP ranges (e.g., RFC1918, 127.0.0.0/8, 169.254.0.0/16) and their equivalent hostnames.
  • Normalize and re-validate URLs after DNS resolution and redirects to ensure they still point to permitted destinations.
  • Consider alternative designs that avoid server-side fetching of user-supplied URLs, such as client-side image uploads with file-type validation.

How teams detect issues like this

Detection can combine code-centric and environment-centric approaches:

  • Static analysis: Flag code paths where user-controlled parameters are passed into HTTP client libraries (e.g., cURL, Guzzle, fetch wrappers) without hostname/IP validation or allowlisting.
  • Code review: Look for features that "fetch remote images/resources for users" and verify they apply robust URL and IP range checks before any request is made.
  • Runtime monitoring: Inspect outbound HTTP logs from the application server for unusual patterns, such as requests to RFC1918 ranges, 127.0.0.1, or cloud metadata endpoints.
  • Network policies: Use firewalls or service mesh policies that alert or block when application workloads attempt to access internal management networks or metadata services.
  • Automated tooling: Integrate security scanners that specifically test SSRF vectors, including requests to internal and metadata IPs, as part of regular CI/CD security testing.

Sources

SourceLink
github.comgithub.com/Bubka/2FAuth/security/advisories/GHSA-8qp3-x2mp-j6f8

Frequently asked

questions

It requires an authenticated user account in the application, but once authenticated, the attacker can provide crafted image URLs that cause the server to issue requests to internal or otherwise unreachable endpoints.

Not necessarily. Any user role that can create or edit OTP entries and set custom image URLs can potentially exploit the SSRF behavior, depending on how roles are configured in a given deployment.

The safest approach is to prevent server-side fetching of arbitrary user-supplied URLs or, if this behavior is required, to enforce strict destination controls: use domain allowlists, block internal and metadata IP ranges, and apply validation before any outbound request is made.

Treat all user-controlled URLs as untrusted, design with the assumption that attackers will try to reach internal networks, enforce outbound network restrictions at the infrastructure layer, and include SSRF-specific checks in code review, threat modeling, and automated security testing.

Find out what's already
exploitable in your codebase.