/

CVE-2026-27638

Severity:

HIGH RISK

(7.1)

Missing Authorization in Actual Sync API for Multi-User

CVE-2026-27638

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Access to and Modification of Sensitive User Data

Severity:

HIGH RISK

(7.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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.

Sources

SourceLink
github.comgithub.com/actualbudget/actual/commit/9966c024cb75f57943193cac8e42f401efed9d08
github.comgithub.com/actualbudget/actual/releases/tag/v26.2.1
github.comgithub.com/actualbudget/actual/security/advisories/GHSA-qmjj-p7m9-wjrv

Frequently asked

questions

Yes. Any remote user who can authenticate to the Actual instance in multi-user OpenID mode can attempt to exploit it by targeting file IDs belonging to other users.

No. The issue can be exploited by any regular authenticated user account; no administrative privileges are necessary.

The most robust fix is to enforce resource-level authorization in all sync endpoints by:

  • Explicitly binding each budget file to a user or tenant identifier, and
  • Verifying that the authenticated user matches this identifier (or has explicit delegated access) before reading or modifying the file.

Establish a consistent access control layer that all handlers must use, require mandatory authorization checks for any operation involving user-specific resources, and enforce these rules via code review, automated tests, and security-focused design guidelines for multi-user and multi-tenant features.

Find out what's already
exploitable in your codebase.