/

CVE-2026-30845

Severity:

HIGH RISK

(8.2)

Sensitive Data Exposure in Wekan Board Integrations

CVE-2026-30845

Analyzed

Vulnerability type

Category:

Sensitive Data Exposure

CWE:

CWE-200, CWE-862

Impact:

Credential Disclosure Leading to Unauthorized Actions in External Services

Severity:

HIGH RISK

(8.2)

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's board composite publication exposes full integration objects, including webhook URLs and authentication tokens, to any client subscribed to a board.

Because board publications are available to all board members and even unauthenticated clients on public boards, any user who can access a board may retrieve webhook credentials and invoke connected external services without authorization.

Affected context

The vulnerability occurs in Wekan deployments that:

  • Run versions 8.31.0 through 8.33
  • Use board integrations such as webhooks or external service connectors
  • Rely on Meteor's DDP publications to deliver board data to clients

In this context, the board composite publication sends integration records to all subscribers without field-level filtering, so secrets like webhook URLs and tokens are exposed to any client that can subscribe to the board publication, including low-privilege members and unauthenticated users on public boards.

Exploit preconditions

  • Attack surface: Wekan's Meteor/DDP API and client subscriptions for board publications
  • Required access:
  • For private boards: any board membership (e.g., read-only, comment-only)
  • For public boards: ability to connect as an unauthenticated DDP client
  • Trigger point: Subscribing to the vulnerable board composite publication for a target board
  • Why exploitation is possible: The publication returns entire integration documents with no field-level filtering, so sensitive fields (webhook URLs, authentication tokens, shared secrets) are included in the data sent to the client, regardless of the client's role or authentication state.

Why this happens

This issue stems from insecure data exposure in a server-to-client publication layer. The Meteor composite publication responsible for serving board data includes related integration documents but does not perform field projection or redaction for sensitive properties.

As a result, it violates the principle of least privilege by providing all integration fields to any subscriber, mapping directly to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor. The access control dimension is reflected by CWE-862: Missing Authorization, because the system fails to enforce that only privileged roles should see secret tokens used to authenticate with external webhooks and services.

Potential impact

  • Attackers may obtain webhook URLs and authentication tokens for integrations tied to a board.
  • Unauthorized parties could invoke external webhooks as if they were the Wekan system.
  • External services integrated with Wekan could process attacker-controlled actions or data.
  • Activity logs or audit trails in external systems may falsely attribute actions to Wekan.
  • In some configurations, attackers could pivot into broader workflows or automation chains triggered by compromised webhooks.

General mitigation guidance

Effective mitigation focuses on tightening data exposure and enforcing authorization boundaries around secrets:

  • Apply field-level filtering on server publications, returning only non-sensitive fields to clients and excluding tokens, shared secrets, and internal identifiers.
  • Introduce separate data paths for secrets, accessible only to backend components or highly privileged administrative APIs, not to general-purpose client subscriptions.
  • Enforce role-based access control at the publication layer so low-privilege users and anonymous clients never receive integration credentials.
  • Use scoped, revocable tokens for webhooks and external integrations so that any exposed credential can be rotated quickly with minimal blast radius.
  • Adopt a secure-by-default schema where secret fields are explicitly marked as confidential and require opt-in exposure only under controlled conditions.

How teams detect issues like this

To detect similar issues, organizations can:

  • Perform code reviews focused on publication/subscription logic, checking that:
  • All data returned by publications uses explicit field projections.
  • Sensitive fields (tokens, secrets, credentials, API keys) are never included in generic publications.
  • Use static analysis or linting rules that flag:
  • Publication handlers returning complete documents without projections.
  • Known secret-field names being passed directly from database queries to publications.
  • Leverage application-level logging and monitoring to:
  • Track which roles and clients are receiving sensitive fields.
  • Detect anomalous access patterns to integration data or unusual DDP subscriptions.
  • Incorporate secret scanning on outbound payloads in pre-production test environments to detect accidental exposure of tokens in client-visible responses.

Sources

SourceLink
github.comgithub.com/wekan/wekan/commit/8c00adc6b865653bd717a946dd646eb54ac78c9c
github.comgithub.com/wekan/wekan/releases/tag/v8.34
securitylab.github.comsecuritylab.github.com/advisories/GHSL-2026-036_Wekan/

Frequently asked

questions

Yes. Any remote client that can connect to the Wekan instance and subscribe to a vulnerable board publication—either as a board member or as an unauthenticated user on public boards—can retrieve the exposed integration data.

For private boards, any board membership is sufficient, including read-only and comment-only roles. For public boards, an attacker may not need any authenticated account at all, only the ability to act as a DDP client.

The safest pattern is to explicitly project only non-sensitive fields in all publications, completely exclude tokens and webhook secrets from client-facing data flows, and move any necessary secret handling into server-side or privileged-only APIs.

Treat integration credentials and webhooks as secrets: design schemas that tag these fields as confidential; enforce least-privilege access at the publication or API layer; adopt code review practices and automated checks that ensure no publication returns full documents without projections; and regularly test endpoints to confirm that clients never receive authentication material they do not strictly need.

Find out what's already
exploitable in your codebase.