Summary
A sensitive information exposure flaw in Discourse allows restricted tag and tag-group names to be disclosed via public category and group endpoints.
When categories are publicly readable, anonymous or unauthorized users may learn about tags that are intended to remain restricted, potentially revealing internal taxonomy or workflow details.
Affected context
This vulnerability occurs in Discourse instances that use restricted tags or tag groups in combination with publicly readable categories.
When tags or tag groups are configured as allowed_tags, allowed_tag_groups, or required tag groups on these categories, the associated names can become visible through category and group-related API endpoints to users who are not permitted to see them.
The issue is limited to the leakage of tag and tag-group names and manifests where authorization checks do not fully align between content visibility and metadata exposure.
Exploit preconditions
- Attack surface: Publicly accessible Discourse category and group endpoints.
- Required access: Anonymous or low-privileged user access to categories that are readable without explicit authorization.
- Trigger point: Requests to category or group endpoints that return configuration metadata about allowed or required tags and tag groups.
- Why exploitation is possible: Authorization logic correctly restricts some content but does not consistently filter or conceal associated tag and tag-group metadata, allowing restricted names to be included in responses.
Why this happens
The underlying issue is incomplete enforcement of access control on configuration metadata associated with categories.
While category content visibility may be governed by appropriate permission checks, the metadata about which tags and tag groups are allowed or required is exposed through endpoints that assume a broader audience.
This maps to CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, where internal or restricted identifiers are inadvertently returned to users without the necessary authorization due to insufficient filtering or segregation of metadata from public responses.
Potential impact
- Unauthorized users may learn names of restricted tags and tag groups that reflect internal projects, clients, or initiatives.
- Attackers could infer organizational structure, incident workflows, or moderation practices from tag taxonomy.
- Knowledge of restricted tags may aid targeted social engineering or reconnaissance efforts.
- Disclosure of internal naming conventions can support more precise guessing of protected content or access patterns.
General mitigation guidance
Effective mitigation generally focuses on aligning metadata exposure with content authorization and minimizing what public endpoints return by default.
Common defensive patterns include:
- Ensuring that category and group endpoints filter out tag and tag-group metadata that is not explicitly intended for public consumption.
- Treating tag names and tag-group identifiers as potentially sensitive metadata, with access tied to the same permissions that govern content tagged with them.
- Designing APIs to separate public configuration data from internal or privileged metadata, using dedicated endpoints with stricter access control where necessary.
- Applying least-privilege principles to metadata, returning only what is required for anonymous or low-privilege users to navigate public content.
How teams detect issues like this
Organizations can detect similar information exposure issues by:
- Reviewing API responses for public endpoints to identify unintended metadata leaks, such as internal tag names or configuration details.
- Using static analysis or automated tests that validate authorization checks around serialized models and their associated metadata.
- Incorporating security-focused code review practices that flag any addition of sensitive identifiers or configuration fields to JSON responses without explicit permission checks.
- Establishing policies that require explicit justification for exposing new fields via public endpoints and enforcing these through automated API contract tests.

