Summary
Appsmith versions 1.94 and below allow unauthenticated users of publicly accessible apps to execute unpublished, edit‑mode actions by manipulating the viewMode parameter in the action execution API.
This breaks the expected publish boundary and can expose sensitive development data, trigger unintended APIs or queries, and cause side-effect behavior that should be limited to authenticated editors.
Affected context
The vulnerability appears in Appsmith instances where applications are shared publicly and rely on a publish boundary to separate end‑user behavior from editor behavior.
Specifically, it affects the /api/v1/actions/execute endpoint when it accepts requests for actions in apps that are publicly accessible and does not strictly enforce that public viewers can execute only published (view‑mode) actions.
The issue is triggered when the API honors viewMode=false or a missing viewMode flag from unauthenticated clients, allowing them to reach edit‑mode behavior that was intended solely for authenticated developers or editors.
Exploit preconditions
- Attack surface: HTTP(S) API for action execution at
POST /api/v1/actions/execute. - Required access: Network access to the Appsmith deployment and knowledge (or guessability) of a public app and its action identifiers; no authentication is required when the app is publicly accessible.
- Trigger point: Sending an action execution request for a public app with
viewMode=falseor omitting theviewModeparameter entirely. - Why exploitation is possible: The authorization logic fails to differentiate between public viewers and authenticated editors for edit‑mode actions, causing the backend to execute edit‑mode queries and APIs based solely on request parameters rather than on the caller's privileges and the app's published state.
Why this happens
This issue stems from missing authorization checks on a sensitive operation: executing edit‑mode actions through the generic action execution API.
Instead of deriving the execution mode from the authenticated user's role and the app's published state, the system trusts a request parameter (viewMode) or its absence to decide whether to run the published or edit‑mode version of an action.
This pattern corresponds to CWE-862: Missing Authorization, where access control decisions are not properly enforced server‑side on a critical function, allowing untrusted clients to select privileged behavior that should only be available to editors or administrators.
Conceptually, the flaw is that the "edit vs. view" separation is treated as a client-controllable mode rather than as a server‑enforced authorization boundary anchored in the user identity and application configuration.
Potential impact
- Unauthenticated users may execute edit‑mode queries and backend APIs intended only for developers or editors.
- Sensitive development or staging data could be exposed through unpublished actions that use different data sources or less restrictive queries than the published version.
- Attackers can potentially trigger side-effect operations (such as mutations, state changes, or integrations) that were not meant to be exposed publicly.
- Information about internal APIs, data models, or debugging behavior may be revealed, aiding further compromise.
- Misuse of edit‑mode actions can lead to data integrity issues if those actions perform write or administrative operations on connected systems.
General mitigation guidance
Long‑term mitigations generally focus on treating "edit vs. view" as a strict authorization boundary enforced on the server:
- Ensure the backend derives execution mode from authenticated user roles, app ownership, and publish status, not from client‑supplied flags like
viewMode. - Introduce centralized policy checks for action execution that verify whether the requester is allowed to access edit‑mode artifacts, with explicit deny‑by‑default behavior for unauthenticated users.
- Separate internal (editor‑only) and public execution paths so that public endpoints never reference or resolve edit‑mode actions or configurations.
- Apply the principle of least privilege to actions: design edit‑mode actions with minimal access and avoid embedding highly sensitive logic or credentials in UI‑level actions where possible.
- For deployments, consider restricting public share capabilities, adding additional authentication for apps with sensitive backends, or placing them behind an access gateway until robust authorization is assured.
How teams detect issues like this
To detect and monitor this class of issue, teams can:
- Use static or configuration analysis to identify endpoints where access level is inferred from client parameters (e.g.,
viewMode,admin=true) instead of authenticated context. - Review backend code or policies for action execution to confirm that authorization checks explicitly differentiate between published and edit‑mode actions, and that unauthenticated callers cannot select edit‑mode behavior.
- Implement automated tests that simulate unauthenticated requests to
/api/v1/actions/executefor public apps, verifying they can only execute published actions and cannot alter execution mode via request parameters. - Add logging and alerting on suspicious patterns, such as repeated unauthenticated requests with
viewMode=falseor unexpected edit‑mode executions originating from public IP ranges. - Integrate security-focused code review or SAST tools configured to flag authorization-sensitive endpoints that accept mode-switching parameters without robust server-side validation.

