Summary
Missing authentication checks on the SimpleFIN and Pluggy.ai integration endpoints in ActualBudget Server allow unauthenticated users to query and retrieve financial data.
When an ActualBudget Server instance with these integrations enabled is reachable over the network, an attacker can read users' bank account balances and transaction histories without logging in.
Affected context
The vulnerability occurs in ActualBudget Server's integration endpoints for SimpleFIN and Pluggy.ai, which are used to synchronize external bank data into the personal finance application.
It affects deployments where:
- ActualBudget Server is exposed over a network (LAN, VPN, or internet), and
- SimpleFIN or Pluggy.ai integrations are configured for at least one user.
In this context, specific server routes responsible for fetching or returning banking data fail to enforce authentication middleware, allowing requests from any network client to be processed as if they were from an authenticated user.
Exploit preconditions
- Attack surface: HTTP(S) endpoints of the ActualBudget Server that handle SimpleFIN and Pluggy.ai integration requests.
- Required access: Network-level reachability to the server (e.g., same local network, VPN, or internet-exposed host); no valid user account or credentials are required.
- Trigger point: An attacker sends crafted HTTP requests to the vulnerable integration endpoints that return balance and transaction data.
- Why exploitation is possible: The affected routes are not wrapped with authentication/authorization middleware, so the server does not verify session state, tokens, or user identity before returning sensitive financial information.
Why this happens
The issue stems from incomplete application of authentication controls on sensitive server routes.
While the application likely has an authentication mechanism for normal user interactions, the integration endpoints for SimpleFIN and Pluggy.ai were implemented without attaching the standard auth middleware or equivalent checks.
This aligns with CWE-306: Missing Authentication for Critical Function, where a function that exposes sensitive data or performs impactful operations fails to verify the caller's identity, thereby treating any network client as implicitly trusted.
Potential impact
- An attacker may read bank account balances associated with ActualBudget users.
- An attacker could retrieve detailed transaction histories, exposing spending patterns, merchant names, timestamps, and amounts.
- Sensitive financial metadata (account identifiers, bank names, currency, etc.) can be disclosed to unauthorized parties.
- Aggregated financial data could be used for profiling, fraud preparation, or targeted social engineering.
- Users' perceived privacy and trust in the application can be significantly undermined.
General mitigation guidance
Mitigation focuses on ensuring that all sensitive integration endpoints are consistently protected by authentication and authorization controls.
Recommended defensive patterns include:
- Centralizing authentication middleware and systematically applying it to all API routes that interact with external financial integrations or return user-specific data.
- Using route-level access control policies that explicitly declare required authentication and user context before handlers run.
- Implementing a default-deny approach where new endpoints are protected by auth checks unless explicitly marked as public.
- Separating public health/status endpoints from private data endpoints, making it harder for sensitive routes to be accidentally exposed.
- Minimizing the amount of financial data returned per request and scoping responses to the authenticated user's identity derived from secure tokens or sessions.
How teams detect issues like this
Organizations can detect and prevent similar issues using layered review and analysis:
- Static analysis: Configure rules to flag HTTP route handlers that access sensitive data (e.g., bank accounts, transactions) without passing through known authentication middleware or guard functions.
- Code review: Require security-oriented reviews for any new integration endpoints, verifying that authentication and authorization checks are present and consistently applied.
- Route inventory: Maintain an annotated catalog of API endpoints, marking each as public or private, and periodically audit that private endpoints enforce authentication.
- Automated testing: Add integration and security tests that attempt unauthenticated access to sensitive endpoints and assert that access is denied.
- Runtime monitoring: Use API gateways, reverse proxies, or WAFs to enforce authentication policies and log anomalous unauthenticated requests to sensitive paths.

