/

CVE-2026-21433

Severity:

HIGH RISK

(7.7)

Server-Side Request Forgery (SSRF) in Emlog Media Handler

CVE-2026-21433

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Server-Side Request Forgery and Internal Network Exposure

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

Emlog up to and including version 2.5.19 contains a server-side request forgery (SSRF) vulnerability where crafted SVG files can cause the server to make outbound HTTP requests to attacker-controlled endpoints.

When the application processes uploaded SVGs that reference external resources, it can be abused as an SSRF/OOB probe into internal networks and cloud metadata services, potentially exposing sensitive information.

Affected context

The vulnerability arises in Emlog's media management functionality, specifically when SVG files uploaded through admin/media.php are later processed or rendered by the server.

Environments that automatically thumbnail, preview, or sanitize SVG content and allow administrators or privileged users to upload SVG files are most exposed.

The risk increases when the Emlog server has access to internal network resources or cloud metadata endpoints that are not directly reachable from the public Internet.

Exploit preconditions

  • Attack surface: HTTP(S) interface for media upload at admin/media.php, handling SVG files.
  • Required access: Ability to upload SVG files (typically authenticated access to the admin/media upload function or any workflow that accepts SVG images).
  • Trigger point: Server-side processing of the uploaded SVG (preview rendering, thumbnail generation, or sanitization that parses the SVG and follows external references).
  • Why exploitation is possible: The SVG renderer or processing pipeline honors external resource references (e.g., image, stylesheet, or other URI-based content) and issues outbound requests without sufficiently restricting destination hosts, schemes, or metadata endpoints.

Why this happens

This issue stems from treating SVG uploads as benign media files while allowing them to contain active external resource references that the server later resolves.

When Emlog (or its underlying image/SVG library) parses an attacker-controlled SVG, it follows embedded URLs server-side, effectively turning the application into an HTTP client that the attacker can steer.

Conceptually, this maps to CWE-918: Server-Side Request Forgery (SSRF): the server initiates network requests based on user-supplied input without adequate validation, host restriction, or separation between untrusted content and network-capable parsing logic.

Potential impact

  • Internal network probing (port scanning and service discovery from the Emlog server's network perspective).
  • Access to internal HTTP-based services that are not exposed publicly.
  • Requests to cloud instance metadata endpoints, which may expose access tokens, IAM credentials, or configuration data.
  • Abuse of the server as an anonymizing proxy to reach third-party targets.
  • Potential pivoting into more sensitive environments if internal services are weakly protected.
  • Increased risk when combined with other vulnerabilities (e.g., if internal endpoints expose management interfaces or RCE primitives).

General mitigation guidance

Given the lack of known patched versions at publication time, mitigation focuses on reducing SVG processing risk and constraining outbound requests:

  • Avoid server-side SVG processing where possible:
  • Prefer disabling SVG uploads entirely, especially for administrative interfaces, or treating SVGs as opaque files without parsing/thumbnailing.
  • Constrain network egress from the application:
  • Use firewall rules or network policies to block the web server from reaching internal-only services and cloud metadata endpoints.
  • Apply least-privilege network segmentation so that the Emlog host can reach only the external services it truly needs.
  • Harden content handling:
  • Use SVG sanitizers or converters that strip or neutralize external references before any rendering.
  • Consider converting SVG uploads to a safe raster format (e.g., PNG) in a sandboxed process that has no outbound network access.
  • Reduce trust in uploader roles:
  • Limit which users can upload SVG or complex media types and prefer safer formats for most workflows.
  • Sandbox media processing:
  • Run image/SVG processing in a separate, locked-down container or service with minimal privileges and no direct network access.

How teams detect issues like this

Detection can focus both on code/configuration analysis and runtime signals:

  • Static and configuration review:
  • Identify code paths where SVG uploads are accepted and subsequently processed, rendered, or sanitized using libraries that follow external references.
  • Look for image or document processing libraries configured with default or permissive fetching behavior (e.g., allowing remote URLs).
  • Review application and infrastructure configuration for unrestricted outbound network access from the web server or media-processing components.
  • Network and runtime monitoring:
  • Monitor outbound HTTP(S) traffic from the Emlog server to unusual destinations, including internal IP ranges (e.g., RFC1918), link-local addresses, and well-known metadata endpoints.
  • Set alerts for spikes in outbound connections triggered shortly after media uploads.
  • Automated tooling:
  • Use web security scanners with SSRF test cases focusing on media upload workflows, including SVG-specific payloads that target known metadata endpoints.
  • Employ SAST/DAST tools or CI/CD checks that flag URL-fetching behavior tied to user-supplied file content.

Sources

SourceLink
github.comgithub.com/emlog/emlog/security/advisories/GHSA-6rwr-c8hc-mjj4

Frequently asked

questions

Yes, if an attacker can obtain access to any workflow that accepts SVG uploads and triggers server-side processing. The attacker does not need direct access to the internal network; they only need the application to accept and process the crafted SVG on their behalf.

Typically, the attacker must be able to upload SVG files through Emlog's media management or any feature that stores and later processes SVG content. In many deployments this is limited to authenticated or administrative users, but misconfigurations can broaden this surface.

The most robust approach is to disable or strictly limit SVG uploads and ensure that any remaining SVG handling occurs in a sandbox without outbound network access. When SVG support is required, sanitize or convert SVGs to non-active formats before rendering and ensure that processing libraries are configured not to follow external URLs.

Treat all complex file formats as potential active content, especially those capable of embedding URLs or scripts. Enforce strict file-type policies, apply defense-in-depth with egress filtering and sandboxed processing, and include SSRF scenarios in your security design reviews and automated testing for any feature that causes the server to initiate outbound network connections based on user-controlled input.

Find out what's already
exploitable in your codebase.