Summary
Maxun versions before 0.0.42 contain a cross-tenant insecure direct object reference issue in storage and webhook API handlers that lets authenticated users access resources belonging to other tenants.
Under certain conditions, attackers can read plaintext Google and Airtable OAuth tokens, and modify, delete, or execute other users' robots by bypassing missing ownership checks in API endpoints.
Affected context
This vulnerability arises in Maxun's multi-tenant environment where storage and webhook-related API endpoints are used to manage robots and OAuth integrations.
It is relevant when tenant isolation relies on application-level ownership checks rather than hard access boundaries, and when robots and OAuth tokens are stored in a way that is directly addressable via identifiers.
The risk is heightened in deployments where OAuth tokens are stored in plaintext and API handlers do not consistently verify that the requesting user owns or is authorized to interact with the targeted robot or token.
Exploit preconditions
- Attack surface: Maxun HTTP API endpoints handling robot storage, execution, and webhook operations.
- Required access: Any authenticated account in the Maxun system; no elevated role required beyond basic API use.
- Trigger point: Supplying crafted identifiers or parameters to storage or webhook handlers that reference robots or tokens belonging to other tenants.
- Why exploitation is possible: The API lacks robust authorization and ownership checks, allowing direct access to objects based solely on their identifiers without confirming tenant membership or resource ownership.
Why this happens
The underlying issue is a classic missing authorization flaw (CWE-862) combined with insecure direct object references in a multi-tenant context.
API handlers for storage and webhook operations appear to rely on object identifiers to fetch robots and OAuth tokens without enforcing tenant-aware authorization checks on each request.
As a result, any authenticated user who can discover or guess valid identifiers may access or manipulate resources that should be scoped to a different user or tenant, breaking isolation guarantees.
Potential impact
- Attackers may read plaintext Google OAuth tokens associated with other users.
- Attackers may read plaintext Airtable access tokens belonging to other tenants.
- Attackers could execute robots owned by other users, potentially triggering unintended workflows or data operations.
- Attackers may modify or delete other users' robots, disrupting automation and causing downtime.
- Attackers can potentially pivot using exposed tokens to access external Google or Airtable data and services.
General mitigation guidance
Effective mitigation centers on enforcing strict, tenant-aware authorization controls at every API boundary that touches shared or sensitive resources.
Common defensive patterns include:
- Implementing ownership and permission checks in all storage and webhook handlers, ensuring that the authenticated principal is authorized for the requested robot or token.
- Avoiding direct reliance on user-provided identifiers; instead, deriving allowed resources from the authenticated context (e.g., tenant ID, user ID) and limiting queries to that scope.
- Designing multi-tenant data models that encode tenant boundaries at the persistence layer and never return cross-tenant records by default.
- Reducing token exposure by storing OAuth secrets securely (e.g., encrypted at rest) and minimizing where plaintext tokens are handled or logged.
- Applying least privilege principles to robots and integrations so that compromise of one account has limited blast radius.
How teams detect issues like this
Detection typically involves a combination of architectural review, code inspection, and automated checks:
- Conducting code reviews to verify that every API endpoint performing read, write, or execution on robots or OAuth tokens enforces authorization based on tenant and user context.
- Using static analysis or linters to flag data access patterns that lack authorization checks or that bypass centralized access-control layers.
- Defining security policies that require use of standardized authorization helpers or middleware for all resource-handling routes and rejecting changes that circumvent them.
- Performing multi-tenant penetration tests and fuzzing API identifiers to detect cases where cross-tenant access is inadvertently permitted.
- Leveraging API gateways or service meshes to enforce coarse-grained access boundaries, which can complement application-level checks.

