Summary
Chartbrew 4.9.0 contains an improper access control vulnerability where dataset and dataRequest endpoints authorize based only on team membership instead of validating that the requested resources belong to the caller's project.
As a result, a low-privileged user with access to a single project can remotely read, create, update, and delete datasets and data requests of other projects in the same team, leading to cross-project data disclosure and unauthorized use of database or API connections.
Affected context
This vulnerability occurs in Chartbrew deployments where teams contain multiple projects and users may have limited, project-scoped roles.
The affected context includes API endpoints handling:
- Dataset operations (read, create, update, delete)
- DataRequest operations (read, execute, create, update, delete)
Instead of consistently enforcing project-level ownership and scoping for dataset_id, dataRequest id, and connection_id, the authorization logic relies on team-level membership.
The issue becomes relevant wherever teams are shared among multiple projects with differing data sensitivity or access expectations.
Exploit preconditions
- Attack surface: Chartbrew HTTP(S) API endpoints for dataset and dataRequest management.
- Required access: Valid, low-privileged project-level credentials for any project within a team.
- Privilege context: The attacker must be a legitimate member of the team but is not granted access to other projects within that team.
- Trigger point: Sending crafted requests referencing dataset_ids, dataRequest ids, or connection_ids that belong to other projects in the same team.
- Why exploitation is possible: The authorization mechanism checks only that the user belongs to the team, without verifying that the targeted resources are tied to one of the projects for which the user is explicitly authorized.
Why this happens
The root cause lies in authorization logic that is too coarse-grained, mapping to CWE-284: Improper Access Control.
Instead of binding dataset_ids, dataRequest ids, and connection_ids to the caller's specific project permissions, the system treats team membership as sufficient authorization for resource operations.
This pattern omits a critical ownership check: the application should confirm that the resource being accessed is within a project the user is allowed to manage.
As a result, project boundaries are not enforced, and internal identifiers from other projects can be operated on by any team member, breaking the intended isolation between projects.
Potential impact
- An attacker can read datasets and data requests from other projects in the same team, potentially exposing sensitive business data.
- An attacker can execute data requests that use other projects' database or API connections, causing unauthorized queries or API calls on behalf of the victim project.
- An attacker can create or modify datasets in other projects, influencing dashboards, reports, and analytics outputs.
- An attacker can delete datasets or data requests from other projects, causing data loss and operational disruptions.
- An attacker can indirectly abuse configured connections to third-party systems, possibly incurring costs or triggering actions in external services.
General mitigation guidance
Mitigation focuses on enforcing fine-grained, resource-level authorization that aligns with project boundaries:
- Ensure that every dataset, dataRequest, and connection is associated with a specific project identifier.
- At each endpoint, validate that the authenticated user has explicit rights to the project owning the referenced dataset_id, dataRequest id, or connection_id before performing the operation.
- Adopt a consistent access control pattern where project-level checks are applied centrally, rather than duplicating ad-hoc checks in individual handlers.
- Favor deny-by-default behavior: if project ownership cannot be established or matched to the user's permissions, reject the request.
- Implement least-privilege roles so that default project-level users have only the minimal capabilities required for their workflows.
- Consider introducing access control middleware or policy enforcement points that encapsulate project-scoped checks and are applied to all relevant routes.
How teams detect issues like this
Detection efforts can focus on both code and runtime signals:
- Static and code review:
- Look for handlers where authorization is based solely on team_id, organization_id, or similar high-level scopes, without cross-checking project_id against the requested resource.
- Identify endpoints that accept dataset_id, dataRequest id, or connection_id and ensure they always join or query through project ownership.
- Use static analysis rules or custom linters to flag access decisions that lack resource-to-owner verification.
- Logging and monitoring:
- Log project_id, team_id, user_id, and resource identifiers for all dataset and dataRequest operations.
- Monitor for patterns where a single user operates across multiple project_ids, especially where the user is not expected to have multi-project access.
- Policy enforcement:
- Introduce unit and integration tests that assert unauthorized access attempts across projects are rejected.
- Use automated security testing or API fuzzing to attempt cross-project operations and verify that they are blocked.

