/

CVE-2026-41455

Severity:

HIGH RISK

(8.5)

SSRF in WeKan Webhook Integrations

CVE-2026-41455

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Unauthorized Data Modification via SSRF

Severity:

HIGH RISK

(8.5)

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 before version 8.35 contains a server-side request forgery (SSRF) flaw in its webhook integration URL handling, where the URL schema field accepts arbitrary strings without protocol or destination validation.

Attackers who can create or modify webhook integrations can direct the server to send HTTP POST requests to internal network targets and abuse response handling to overwrite comment text without proper authorization checks.

Affected context

This vulnerability arises in WeKan installations that expose the webhook integration feature and allow users or integrations to specify arbitrary webhook endpoint URLs.

The issue is most relevant where the WeKan server has network access to internal services, cloud metadata endpoints, or other sensitive infrastructure that is not exposed to end users.

The absence of protocol and destination restrictions means any string can be treated as a URL, and response data from those server-initiated requests can influence comment content without passing through normal authorization paths.

Exploit preconditions

  • Attack surface: Web interface or API endpoints used to configure or update webhook integrations.
  • Required access: Ability to create or modify webhook integrations (e.g., a user account with board or integration management permissions).
  • Trigger point: A board event that fires the webhook (such as card creation, update, or comment activity), causing the server to issue an HTTP POST to the attacker-specified URL.
  • Why exploitation is possible:
  • The URL schema field accepts arbitrary strings without enforcing allowed protocols (e.g., only http/https) or validating destinations (e.g., blocking localhost, metadata services, or internal address ranges).
  • The server performs outbound requests on behalf of the application using its own network position, effectively proxying access to internal resources (classic SSRF).
  • Response handling related to webhook processing can be abused so that data from these requests is used to overwrite comment text without passing standard authorization checks.

Why this happens

The core issue maps to CWE-918: Server-Side Request Forgery (SSRF), where the server is tricked into making HTTP requests to arbitrary locations due to insufficient validation of user-supplied URLs.

In this design, the webhook integration URL is treated as trusted configuration even though it is supplied by users who may control or influence it.

No canonicalization or access control is applied to constrain the target address, protocol, or path, allowing the WeKan server—running with its own network privileges—to reach internal or otherwise restricted services.

In addition, logic that processes webhook responses is not properly bound to the authenticated user's permissions; returned data can influence comment content even when the integration author has no rights to edit those comments, leading to unauthorized data modification as a secondary effect of the SSRF behavior.

Potential impact

  • Discovery and interaction with internal network services that are not directly exposed to users.
  • Access to sensitive internal HTTP endpoints, including administrative interfaces or cloud metadata services, depending on the environment.
  • Use of WeKan as a pivot point for further attacks inside the network (e.g., reconnaissance or service probing).
  • Overwriting or tampering with comment text on boards without normal authorization, potentially leading to misinformation, data integrity issues, or abuse.
  • Leakage of board event payloads to attacker-controlled internal endpoints, exposing potentially sensitive collaboration data.

General mitigation guidance

Effective mitigation focuses on strictly controlling where the application is allowed to send outbound requests and decoupling external responses from authorization-sensitive operations:

  • Enforce an allowlist of safe protocols (typically only https and, where necessary, http) for webhook URLs; reject or ignore other schemes.
  • Apply URL and IP validation that blocks access to internal address ranges (e.g., loopback, link-local, private RFC1918 ranges, and known metadata IPs) unless explicitly required and justified.
  • Resolve hostnames and perform post-DNS validation to prevent DNS rebinding and ensure the final destination remains within allowed ranges.
  • Introduce a dedicated outbound request layer or proxy that enforces network egress policies and timeouts, rather than allowing direct arbitrary connections from application code.
  • Treat data from webhook responses as untrusted: validate structure, limit size, and avoid binding it directly to privileged actions such as editing comments; ensure all state changes pass through standard authorization checks.
  • Apply the principle of least privilege to the application's network environment, isolating WeKan from unnecessary internal services via firewall rules, container network policies, or segmentation.

How teams detect issues like this

Identifying and monitoring this type of vulnerability typically involves a mix of code analysis and operational controls:

  • Static analysis and code review:
  • Search for outbound HTTP clients or webhook handlers that use user-controlled URLs without canonicalization or destination checks.
  • Look for URL handling paths that lack validation logic for protocol, host, and IP range restrictions.
  • Examine response-handling code for paths where external data can alter comments or other user-visible content without explicit permission checks.
  • Configuration and policy enforcement:
  • Implement network egress policies (e.g., firewall rules, Kubernetes NetworkPolicies, or service mesh policies) to prevent application containers from reaching internal or sensitive endpoints by default.
  • Use automated checks in CI/CD to flag changes that introduce new outbound request destinations or relax URL validation.
  • Runtime monitoring:
  • Log webhook configuration changes and alert on URLs pointing to internal IP ranges or unusual domains.
  • Monitor outbound traffic patterns from the WeKan server for unexpected destinations or spikes that may indicate SSRF probing.
  • Automated application security testing tools and SSRF-focused scanners can help discover unsafe URL sinks and verify that validation rules are effective.

Sources

SourceLink
github.comgithub.com/wekan/wekan/commit/2cd702f48df2b8aef0e7381685f8e089986a18a4
github.comgithub.com/wekan/wekan/releases/tag/v8.35
vulncheck.comvulncheck.com/advisories/wekan-ssrf-via-webhook-url

Frequently asked

questions

Yes, in most deployments it is remotely exploitable by any authenticated user who can create or modify webhook integrations. The actual reach depends on the permissions model and whether untrusted users have access to integration configuration.

The attacker generally needs an account with the ability to define or update webhook integrations on a board. They do not need direct access to the internal network; the WeKan server performs the internal HTTP requests on their behalf.

The safest pattern is to strictly validate and constrain webhook URLs (protocol, host, and IP ranges), route all webhook traffic through controlled egress mechanisms, and ensure that any updates to comments or other content always pass through standard authorization checks rather than relying on integration responses.

Design integration and webhook features under the assumption that configuration values, including URLs, are attacker-controlled. Implement defense-in-depth: URL and IP validation, network egress restrictions, response sanitization, and robust authorization checks for any state changes driven by external services. Incorporate SSRF-specific checks into code review and automated security testing practices.

Find out what's already
exploitable in your codebase.