Summary
In multi-user mode using OpenID, Actual's sync API endpoints fail to verify that the authenticated user is authorized to access the requested budget file.
As a result, any authenticated user can read, modify, or overwrite another user's budget data by supplying their file ID, exposing sensitive financial information and risking data integrity.
Affected context
This vulnerability appears in Actual deployments configured in multi-user mode with OpenID-based authentication.
It specifically affects the /sync/* API endpoints that operate on budget files by file ID.
The issue manifests when the application assumes that a valid OpenID-authenticated session is sufficient and does not perform a per-resource ownership or access check before serving or modifying budget data.
Exploit preconditions
- Attack surface: HTTP(S) sync API endpoints under
/sync/*exposed to authenticated users. - Required access: Any valid authenticated user account within the Actual instance (OpenID login required, but no special roles).
- Trigger point: The attacker issues sync requests with a target file ID that belongs to another user.
- Why exploitation is possible: The backend logic trusts that any authenticated user can operate on any file ID and does not validate whether the requesting user owns or is authorized to access that specific budget file.
Why this happens
The core issue is a missing authorization check on resource access after authentication has occurred.
While OpenID establishes that the requester is a known user, the sync handlers fail to enforce a "check-after-auth" pattern that ties each file ID to a specific account or access control list.
This aligns with CWE-862: Missing Authorization, where an application authenticates users but neglects to verify whether they are allowed to perform actions on a given resource, leading to insecure direct access to other users' data.
Potential impact
- An authenticated user may read other users' budget files and access sensitive financial information.
- An authenticated user could modify or overwrite another user's budget data, causing data corruption or loss.
- Users' financial histories and plans could be tampered with, undermining trust in the integrity of stored records.
- Compromised or malicious user accounts could be used to systematically harvest or sabotage all accessible budget files on the instance.
General mitigation guidance
Effective mitigation focuses on enforcing strict resource-level authorization and isolating user data by identity:
- Introduce explicit ownership checks for every sync operation, ensuring that the requesting user's identity matches or is authorized for the target file.
- Avoid relying solely on authentication status; always couple authenticated sessions with resource-scoped authorization logic (e.g., user ID or tenant ID bound to each file).
- Use strong multi-tenant design patterns that partition data by user or account and never allow direct file ID access without verifying ownership.
- Apply least-privilege principles so that each authenticated user only has access to their own budgets unless explicitly shared under defined policies.
- Implement secure-by-default access patterns in new APIs, requiring explicit opt-in for any cross-user or shared access.
How teams detect issues like this
Organizations can detect and monitor for similar authorization flaws by:
- Performing code reviews focused on authorization boundaries, verifying that all resource-handling endpoints enforce identity and ownership checks.
- Using static analysis or linting rules that flag handlers which accept resource identifiers (e.g., file IDs) but lack corresponding authorization calls.
- Applying security testing and fuzzing that attempt cross-user access (e.g., using one user's session to access another user's file ID).
- Enabling detailed access logging that records user identity, target resource IDs, and outcomes, and then reviewing logs for anomalous cross-user access patterns.
- Incorporating automated security testing into CI/CD to validate that new or changed endpoints follow a consistent authorization middleware or policy enforcement pattern.

