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()andparseActions(), which extract attachment URLs and pass them toAttachments.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.

