/

CVE-2026-30844

Severity:

HIGH RISK

(8.1)

SSRF in Wekan Board Import Attachment Handling

CVE-2026-30844

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources via server-side HTTP requests

Severity:

HIGH RISK

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

Wekan versions 8.32 and 8.33 contain a Server-Side Request Forgery (SSRF) vulnerability in the board import functionality, where attachment URLs from user-supplied JSON are fetched directly by the server without validation.

An authenticated user can abuse this behavior to make the Wekan server perform arbitrary HTTP requests, potentially reaching internal services such as metadata endpoints, databases, or admin panels that are not accessible from the public internet.

Affected context

The vulnerability appears in Wekan's board import workflows, specifically when importing boards from Wekan or Trello using JSON files that include attachments.

In these flows, user-controlled JSON is accepted and processed on the server, and attachment URLs found in the JSON are fetched by the backend as part of recreating cards and their associated files.

The issue is present when the application:

  • Accepts board import JSON from authenticated users
  • Parses activity/action data containing attachment URLs
  • Uses the server's network context to download those URLs without applying any host, scheme, or IP validation.

Exploit preconditions

  • Attack surface: Wekan board import endpoints (Wekan and Trello import flows).
  • Required access: Authenticated access to Wekan with permission to import boards (typically any logged-in user who can use the import feature).
  • Input control: Ability to supply or modify JSON import data to include arbitrary attachment URLs.
  • Trigger point: Execution of parseActivities() and parseActions(), which extract attachment URLs and pass them to Attachments.load() for download.
  • Why exploitation is possible: The server trusts the user-supplied attachment URLs and performs HTTP requests without validating destination hosts, IP ranges, or protocols, allowing requests to internal or otherwise restricted endpoints.

Why this happens

The core issue is a lack of output validation on server-initiated HTTP requests whose targets are derived from user input.

Wekan's parseActivities() and parseActions() functions treat attachment URLs from imported JSON as benign and pass them directly to Attachments.load() for retrieval.

This pattern aligns with CWE-918: Server-Side Request Forgery (SSRF), where an application uses untrusted user-controlled URLs to initiate server-side requests, implicitly extending the attacker's reach into internal networks and protected resources.

Conceptually, the bug stems from coupling "imported data reconstruction" with "unrestricted URL fetching" and assuming that URLs embedded in import data are trustworthy.

Potential impact

  • Access to internal HTTP services not exposed to the public internet (e.g., admin consoles, monitoring dashboards).
  • Interaction with cloud instance metadata services, which may expose IAM credentials or access tokens.
  • Probing of internal network topology and open ports using the application server as a proxy.
  • Potential access to internal databases or configuration endpoints exposed over HTTP.
  • Use of the application server's identity and IP address to bypass IP‑based access controls or firewalls.

General mitigation guidance

Effective mitigation focuses on constraining where the server is allowed to connect and reducing trust in user-provided URLs:

  • Implement strict allowlists for outbound requests initiated during imports, limiting downloads to approved domains or storage services.
  • Reject or normalize URLs that resolve to private, loopback, link-local, or unspecified IP ranges, and disallow protocols other than HTTPS/HTTP where appropriate.
  • Separate parsing of import data from retrieval of external resources; consider requiring users to manually upload attachments instead of auto-downloading arbitrary URLs.
  • Enforce robust URL parsing and DNS resolution checks on the backend to prevent bypasses via redirects, DNS rebinding, or encoded IP formats.
  • Run the application with least-privilege network access, potentially using network segmentation or egress filters to block access to sensitive internal services.

How teams detect issues like this

To detect this class of issue and its potential abuse:

  • Use static analysis or code review to identify locations where user-controlled URLs or hosts are passed into HTTP client libraries without validation or allowlisting.
  • Establish secure coding guidelines that flag patterns such as direct URL fetching from import/parsing routines (e.g., data import, webhooks, or metadata fields).
  • Monitor application logs and network telemetry for unusual outbound connections, especially to internal ranges (e.g., 169.254.169.254, RFC1918 IPs, localhost).
  • Integrate security scanning into CI/CD to check for SSRF patterns, including taint analysis from request bodies to outbound HTTP APIs.
  • Apply infrastructure-level controls (proxies, firewall rules, egress policies) and periodically review logs for anomalous request destinations initiated by application servers.

Sources

SourceLink
github.comgithub.com/wekan/wekan/commit/62216e36c15f55d4ef6cb97313db3aa54fc77fe0
github.comgithub.com/wekan/wekan/releases/tag/v8.34
securitylab.github.comsecuritylab.github.com/advisories/GHSL-2026-045_Wekan/

Frequently asked

questions

It is exploitable by any authenticated user who can access the board import functionality. While an external attacker needs an account or compromised credentials, they can then leverage the server to reach internal resources that are not directly exposed to the internet.

Not necessarily. The key requirement is access to the board import feature and the ability to upload or control import JSON data. If regular users can import boards, they may be able to exploit the vulnerability.

The most robust approach is to prevent the server from fetching arbitrary user-supplied URLs. This typically involves enforcing strict allowlists for outbound requests, rejecting private or loopback destinations, and decoupling data import from automatic fetching of external attachments.

Treat any user-influenced URL or hostname as untrusted, enforce centralized validation and allowlisting before making outbound requests, and apply network-level egress controls. Incorporate SSRF-specific checks in code review and automated testing, especially around import, webhook, and integration features that initiate HTTP requests on behalf of users.

Find out what's already
exploitable in your codebase.