Summary
An information disclosure flaw in an issue tracking notification API allows private issue metadata to remain accessible even after a user's access has been revoked.
When notification mechanisms do not re-check authorization on delivery, an attacker who previously had access can continue to receive sensitive issue details, exposing confidential project or security information.
Affected context
This vulnerability typically appears in systems that provide notification or subscription APIs for issue tracking or ticketing workflows.
It is most relevant where:
- Users can follow or subscribe to issues, tickets, or discussions
- Access to issues is governed by roles, groups, or project permissions
- Notification endpoints or background jobs rely on cached or historical authorization state
Under these conditions, revoking a user's access to a project or issue may not immediately propagate to all notification channels, leaving a window where private metadata continues to leak.
Exploit preconditions
- Attack surface: Issue notification API, webhooks, push notifications, or email generation endpoints
- Required access: Prior legitimate access to the issue or project, plus an active notification subscription or delivery channel
- Trigger point: Delivery of notifications after access revocation (e.g., status changes, comments, or field updates)
- Why exploitation is possible: The notification subsystem does not consistently revalidate permissions at send time, relying instead on outdated authorization data or subscription state that was established before revocation
Why this happens
The underlying bug is a classic authorization mismatch between core data access and secondary delivery mechanisms.
While direct reads of issue metadata may correctly enforce permissions, the notification API or background jobs can bypass or reuse stale authorization decisions.
This maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, because sensitive issue details (such as titles, descriptions, tags, or internal comments) are exposed through a side channel that fails to respect updated access controls.
Abstractly, the insecure pattern is relying on one-time permission checks (at subscription time) instead of continuous enforcement at every path where sensitive data is transmitted.
Potential impact
- Unauthorized parties may receive ongoing updates about private issues
- Sensitive project or security incident metadata could be disclosed
- Internal comments and workflow states can be exposed outside intended teams
- Regulatory or contractual confidentiality requirements may be violated
- Attackers could infer system architecture, incident handling processes, or security weaknesses from leaked issue details
General mitigation guidance
Effective mitigation focuses on aligning notification delivery paths with core authorization logic and treating notifications as high-risk data flows.
Common secure patterns include:
- Performing fresh authorization checks at notification generation time, using the same access control logic as primary read endpoints
- Designing subscriptions as references that always respect current permissions, rather than immutable grants
- Minimizing sensitive metadata in notifications, using redaction or summarization where possible
- Applying least-privilege principles to roles and groups so that issue access is tightly scoped
- Centralizing authorization decisions so that all APIs and background workers consume a single, consistent policy engine
These patterns help ensure that revocation is honored across all delivery mechanisms, not just direct UI or API reads.
How teams detect issues like this
Detection often involves both technical and process-oriented approaches:
- Reviewing notification and webhook code for any paths that construct issue payloads without explicit, up-to-date permission checks
- Using static analysis or policy-as-code tools to flag data flows that bypass central authorization utilities
- Implementing logging that correlates notification delivery with current permission state, then monitoring for mismatches
- Conducting targeted access review tests: revoke access for test accounts and verify that no further notifications containing sensitive details are delivered
- Enforcing architectural guidelines that require all secondary data channels (emails, webhooks, push notifications) to call shared authorization services

