/

CVE-2026-34428

Severity:

HIGH RISK

(7.7)

SSRF in Vvveb oEmbedProxy Endpoint

CVE-2026-34428

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network and Local File Exposure via SSRF

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

Vvveb prior to version 1.0.8.1 contains a server-side request forgery (SSRF) vulnerability in the oEmbedProxy action of the editor/editor module, where the url parameter is forwarded directly to curl without validating the scheme or destination.

Authenticated backend users can coerce the server into fetching arbitrary file:// and internal http:// resources, potentially exposing local files and internal network services through the application's response.

Affected context

This issue affects Vvveb instances that:

  • Expose the editor/editor backend module with the oEmbedProxy action enabled to authenticated users
  • Use server-side HTTP requests via curl to retrieve oEmbed or remote content based on a user-supplied url parameter
  • Do not restrict or validate URL schemes (e.g., file://, http://, https://) or destination hosts, ports, or IP ranges

The vulnerability is most relevant in deployments where the web server has access to internal-only services (e.g., databases, admin panels, metadata services) or sensitive local files readable under the web server's OS account.

Exploit preconditions

  • Attack surface: The oEmbedProxy action in the backend editor/editor module, reachable by authenticated backend users.
  • Required access: Valid backend authentication or equivalent privilege that allows invoking the vulnerable action.
  • Trigger point: Supplying a crafted url parameter (e.g., file://... or internal http:// target) that is passed directly to curl via getUrl() without validation.
  • Why exploitation is possible: The server trusts and forwards the user-controlled url parameter to a generic HTTP client without enforcing scheme restrictions, destination filtering, or network egress controls, allowing requests to internal networks and local resources with the web server's privileges.

Why this happens

The root cause is an SSRF design flaw where user-controlled input is used to drive server-side HTTP/file retrieval without any trust boundary checks. The oEmbedProxy action accepts a url parameter and passes it directly to getUrl() using curl, failing to:

  • Restrict allowed URL schemes to safe values (e.g., https and possibly http only)
  • Enforce allowlists or denylists for hostnames, IP ranges, and ports
  • Prevent access to loopback, link-local, and private network address space
  • Block non-HTTP schemes such as file:// that map to local filesystem access

This pattern aligns with CWE-918: Server-Side Request Forgery (SSRF), where an application uses attacker-controlled URLs for outbound requests, enabling abuse of the server's network position and file access rights.

Potential impact

  • Disclosure of local files readable by the web server process via file:// URLs (e.g., configuration files, application logs, or environment metadata)
  • Probing and enumeration of internal network services that are not directly accessible from the attacker's network
  • Access to sensitive internal HTTP services (e.g., admin dashboards, internal APIs, metadata services) if reachable from the web server
  • Use of the application as a pivot point for further attacks within the internal network (e.g., banner grabbing, service discovery)
  • Potential leakage of secrets stored in configuration files if they are readable by the web server account

General mitigation guidance

Effective mitigation centers on strictly controlling how external resources are fetched and reducing trust in user-supplied URLs:

  • Scheme restriction: Only allow safe schemes (e.g., https, possibly http) and explicitly block file://, gopher://, ftp://, and other non-HTTP schemes.
  • Destination validation: Implement strict allowlists for domains or IP ranges that oEmbed is permitted to contact, and reject requests to private, loopback, link-local, and link-local metadata IP ranges.
  • URL normalization and parsing: Use robust URL parsing utilities to canonicalize and inspect the target before issuing any request, ensuring checks are applied to the final destination after redirects are considered.
  • Network egress controls: Where possible, apply firewall or container/network policy rules so that the web server cannot reach sensitive internal infrastructure or local metadata endpoints.
  • Principle of least privilege: Run the web application under an account with minimal file system privileges, reducing the impact of any file-reading capabilities.
  • Safe proxying pattern: Consider using a curated set of pre-configured providers or server-side mapping instead of letting users submit arbitrary URLs for server-side fetching.

How teams detect issues like this

Organizations can detect and monitor SSRF risks in this context using:

  • Static analysis: Rules that flag direct use of user-supplied URL parameters in outbound request functions (e.g., curl, HTTP clients) without validation, especially in proxy or embed-related actions.
  • Code review: Manual review of any endpoint that proxies or fetches remote content; red flags include arbitrary url parameters forwarded to HTTP clients without allowlists or scheme checks.
  • Configuration and policy enforcement: CI/CD checks or linters that enforce patterns such as "no direct use of request parameters in HTTP client calls" and require wrapper utilities that implement central URL validation.
  • Runtime monitoring: Network monitoring or web application firewall rules to alert on unusual outbound requests from the web server, especially to internal IP ranges or via file://-like indicators in logs.
  • Logging and auditing: Detailed logging of outbound request destinations initiated by application features like oEmbed, with periodic analysis for anomalous internal or local targets.

Sources

SourceLink
github.comgithub.com/givanz/Vvveb/commit/2d356844f37819bf771e7cd5e12a8686975e0b2b
github.comgithub.com/givanz/Vvveb/releases/tag/1.0.8.1
vulncheck.comvulncheck.com/advisories/vvveb-ssrf-via-oembedproxy

Frequently asked

questions

Exploitation is limited to authenticated backend users or anyone who can access the oEmbedProxy action with sufficient privileges. However, within that scope it can be potent, as it allows those users to leverage the server's network position and file system access to reach resources they could not otherwise access directly.

No special network access is required beyond connectivity to the vulnerable Vvveb instance. Once authenticated, the attacker can trigger server-side requests to internal or local resources that the server can reach, even if those resources are not exposed to the attacker's own network.

The safest pattern is to never allow arbitrary user-supplied URLs to be fetched by the server. Instead, rely on a strict allowlist of trusted domains or pre-configured providers, enforce scheme restrictions, and centralize URL validation in a dedicated utility that all outbound requests must use.

Developers can prevent SSRF by treating all URLs derived from user input as untrusted, using centralized validation logic, enforcing allowlists and scheme checks, applying network-level egress restrictions, and including SSRF checks in code review and security testing processes, especially for any feature that proxies or previews remote content.

Find out what's already
exploitable in your codebase.