Summary
Taubyte Tau's services/auth HTTP service does not verify whether an authenticated user owns or may access the project identified in a request. Any user with a valid GitHub OAuth token may therefore read or permanently delete another tenant's project by supplying its project ID to the affected endpoints.
Affected context
The vulnerability occurs in Taubyte Tau deployments where the services/auth HTTP service exposes project retrieval and deletion endpoints. The risk is present when authentication confirms only that a GitHub token is valid, while authorization does not bind the requested project to the authenticated tenant or permitted project scope.
Exploit preconditions
- Attack surface: The services/auth HTTP API, specifically project resource endpoints
- Required access: Any valid GitHub OAuth token accepted by the service
- Target input: An arbitrary project identifier supplied in the request path
- Trigger point: A request to the project retrieval or deletion operation
- Why exploitation is possible: Authentication succeeds without an object-level ownership or permission check before project data is fetched or deleted
Why this happens
The service separates authentication from authorization but fails to enforce authorization at the project-object level. After validating that a caller possesses a valid GitHub token, it performs project lookup or deletion using the supplied identifier without confirming that the caller has access to that project. This is characteristic of CWE-639, Authorization Bypass Through User-Controlled Key, where an attacker-controlled object reference is trusted without an ownership or permission decision.
Potential impact
- An attacker may read another tenant's project information
- An attacker could permanently delete projects belonging to other tenants
- Project availability and tenant isolation may be compromised
- A successful attack may enable data loss, operational disruption, or follow-on abuse of affected project resources
General mitigation guidance
Mitigation generally focuses on enforcing object-level authorization for every
project operation, rather than relying on token validity alone.
Common defensive patterns include:
- Resolve the caller's tenant and permissions from trusted server-side identity data
- Check project ownership or explicit access rights before every read, update, or delete operation
- Prefer server-side authorization scopes and tenant-bound resource lookups over direct identifier trust
- Return consistent authorization failures without exposing whether unrelated project identifiers exist
- Apply least privilege to service identities and separate destructive permissions from read access where practical
- Use secure-by-default API policies that deny access unless an explicit project-level grant is present
How teams detect issues like this
Organizations can identify similar authorization flaws through:
- Static analysis and code review searches for handlers that use path parameters directly in fetch or delete operations
- Review signals showing authentication middleware without a subsequent ownership, tenant, or permission check
- Authorization tests that access the same object through identities from different tenants
- Negative tests covering guessed, enumerated, stale, and cross-tenant project identifiers
- API gateway or policy enforcement that requires tenant-bound resource authorization for object operations
- Audit monitoring for repeated access or deletion attempts involving projects outside the caller's normal tenant scope

