News · Published 2026-11-07
Appwrite Incident 1 Nov 2026: Rotate Secrets
Appwrite Cloud runtime escape on 1 November 2026: who was notified, which secrets to rotate, and the 2.7.1 upgrade for self-hosters. A heads-up, not tested.
TL;DR
- Appwrite Cloud was hit on 1 November 2026. An attacker running code in their own project exploited the function runtime and read the configuration of an internal service in the Frankfurt region, which held several internal credentials. Appwrite published its report on 4 November.
- One credential matters for customers. From 03:53 to 14:46 UTC on 1 November, an access token could read the configuration, environment variables included, of every Function and Site on the Frankfurt compute. Appwrite has no record of anyone using it and found no evidence that variables were read.
- That is not the same as "not read". The infrastructure provider's audit log for the window is incomplete and cannot be recovered, so Appwrite says it cannot fully rule it out. It notified the owners of 1,022 projects.
- If Appwrite emailed you: treat the listed secret variables as exposed. Create new values at the service that issued them, revoke the old ones, update the variable, redeploy, and read the issuer's logs since 03:53 UTC on 1 November.
- If you did not get an email, Appwrite says none of your projects met its conditions.
- If you self-host: the cloud incident did not happen on your instance, but the same root-cause fix ships in 2.7.1. The upgrade guide adds a step the incident report does not: rotate
_APP_EXECUTOR_SECRETif people you do not fully trust can deploy functions. - Not verified: everything. We ran nothing, and we cannot check Appwrite's forensics. See the last section.
How this was checked
Read on 7 November 2026 from these pages: Appwrite's incident report (published 4 November 2026), the changelog entry for 2.7.1, the updates and migrations guide and the Functions environment variables page.
Nothing was run. We have no Appwrite Cloud project and did not run an upgrade. Statements about what happened are Appwrite's, and we say "Appwrite says" where it matters. Sentences marked our reasoning are inferences, not statements from Appwrite.
What happened
All of this is Appwrite's account.
30 to 31 October. An attacker targeted one customer's application and got in through weaknesses in that customer's own code and setup, not through a vulnerability in Appwrite. Appwrite worked with that customer directly.
1 November. The attacker created functions in a project of their own and used them against the platform. The runtime is meant to keep customer code away from the services around it. A service that routes traffic to Functions and Sites in Frankfurt "handled files written by customer code unsafely", and the attacker used that to read the service's configuration. Appwrite's fix description says the services followed links planted by customer code and read files that were not plain files.
The attacker used three of the credentials in that configuration, mostly against the customer they were already targeting. Appwrite says its own and its providers' logs show the attacker read that customer's function code and logs, ran one of that customer's functions, and swapped its code for 31 seconds before putting it back. They also listed Appwrite's internal storage, wrote test files into their own project, and made one change to the content delivery setup that was never activated. Appwrite says the storage provider's request log shows they read no other customer's files.
In the same session the attacker used a second, unrelated storage API vulnerability that let a request write outside its project's storage. Appwrite says the only file written was the attacker's own test file, and it deleted the file and fixed the bug.
| Time (UTC) | What happened, per Appwrite |
|---|---|
| 30 to 31 October | One customer's application is compromised through that customer's own code and setup. |
| 1 November, 03:53 | The attacker exploits the runtime vulnerability from their own project and gets the Frankfurt service's credentials. |
| 1 November, 04:06 to 13:33 | Some credentials are used against the one customer and to probe storage and content delivery. |
| 1 November, 14:46 | A routine release replaces the affected service. The access token stops working. |
| 2 November | Automated security monitoring detects the attack. Within hours Appwrite blocks the accounts and projects, ships the fix and replaces every exposed credential. |
| 2 to 4 November | Appwrite works out which customers had secrets in reach and checks those projects for misuse. |
| 4 November | Notifications start. |
The credential that matters, and why "no evidence" is not "no access"
The report is about a different credential from the three the attacker used: an access token that could read the configuration of every function and site on the Frankfurt compute. Appwrite has no record of anyone using it.
The gap: the infrastructure provider's audit log for the window is incomplete because of a fault on the provider's side, and the missing records cannot be recovered. Appwrite checked what it could instead: every change to the compute's configuration, every workload started and every interactive session opened. It says all of it traces back to its own systems and staff, and adds that these records cannot show a read.
Our reasoning: a read of environment variables with a valid token leaves a trace only in a log that records reads. If that log has a hole, the honest conclusion is the one Appwrite draws: no evidence, cannot exclude. That is why the rotation advice is unconditional for the listed variables.
Who was notified
Appwrite notified the owners of 1,022 projects. A project is on the list if all of these are true:
- It had a Function or Site running on the Frankfurt compute between 03:53 and 14:46 UTC on 1 November. That compute also serves Sites for projects in other regions, so some of those projects are on the list.
- The Function or Site had an environment variable set before 14:46 that day.
- The variable's name marks it as a secret: a key, token, password or database connection string. Appwrite left out variables that are public by design, such as publishable keys and public client IDs.
If you were not contacted, Appwrite says none of your projects met these conditions. Our reasoning: the criteria go by variable name. A secret stored under a name that does not look like one (for example CONFIG holding a JSON blob with a key inside) may not have counted. If you run on the Frankfurt compute and have such variables, rotating them anyway costs little. Appwrite does not say how it treated these, so ask them at security@appwrite.io if it matters to you.
What to do if Appwrite emailed you
This is Appwrite's list, in our order. Most of the secrets belong to services outside Appwrite, which Appwrite cannot rotate for you.
- Create a new value at the issuer of each listed secret (payment, email, AI or database provider, and so on).
- Revoke the old value. A new key next to a still-valid old one protects nothing.
- For Appwrite API keys, create a new key with only the scopes the function needs.
- Update the variable in each affected Function or Site.
- Redeploy, so running copies pick up the new value. Appwrite's documentation says variable changes "only take effect on the next deployment".
- Delete the old Appwrite API key once the new deployment works.
- Read the issuer's logs for activity you do not recognize since 03:53 UTC on 1 November.
Order matters for a database password. Our reasoning: if the database cannot hold two credentials at once, plan the switch so the new password is set, the consumers are redeployed and checked, and only then the old one is revoked. Where the issuer supports two active credentials, use that.
Two habits worth keeping while you do this, both ours: do not paste secret values into tickets, chat or CI logs, and write down for each secret who owns it, when it was rotated and how you checked that the new one works.
What to do if you self-host
Appwrite says the incident happened on Appwrite Cloud. For self-hosted instances it says to upgrade to 2.7.1, "which brings the same root-cause fix". The changelog calls it a security release for the 2.7 line with several security fixes, and recommends upgrading strongly.
The update guide adds details that the incident report does not:
- What the old executor did. 2.7.1 updates the Open Runtimes executor from 1.1.2 to 1.3.1. Appwrite writes that the old executor followed symlinks that a function or site planted in its logs, build output or build cache, so a deployment could read files from the executor container, including
_APP_EXECUTOR_SECRET. With that secret, code in a function can call the executor directly, and the executor controls Docker on the host. - The condition for action. "If anyone you don't fully trust can deploy functions or sites on your instance, upgrade and then rotate
_APP_EXECUTOR_SECRET." Our reasoning: on a single-team instance where every deployer is trusted, the risk is smaller. On anything multi-tenant, treat the rotation as part of the upgrade. - The upgrade itself. Back up first. 2.7.1 upgrades from 1.9.6 or any later version. From 2.7.0 it only replaces the images, with no schema changes, so the migration has nothing to change. The documented sequence is the upgrade container with the
2.7.1tag, then the migration:
# Documented by Appwrite, not run here. Back up first.
docker run -it --rm \
--publish 20080:20080 \
--volume /var/run/docker.sock:/var/run/docker.sock \
--volume "$(pwd)"/appwrite:/usr/src/code/appwrite:rw \
--entrypoint="upgrade" \
appwrite/appwrite:2.7.1
cd appwrite/
docker compose exec appwrite migrate- If you maintain your own compose file, set the
openruntimes-executorimage toopenruntimes/executor:1.3.1and rundocker compose up -d. - Rotating the executor secret: set a new
_APP_EXECUTOR_SECRETin.envand rundocker compose up -d. Appwrite says this recreates the API, the workers and the executor together, so nothing needs the old value. - Skipping versions: if you are coming from older releases, the guide asks you to follow the upgrade notes of each release you skip, and lists them.
- Staying on 1.9: the guide says to upgrade to 1.9.10, which also fixes the Brotli decoder vulnerability CVE-2026-111497 and backports security fixes from 2.6.2. Some fixes tighten defaults, so read its release notes first. We covered that CVE in Node2Shell (CVE-2026-111497): Patch and Verify.
To check the result, the guide says to run docker ps | grep appwrite/appwrite and confirm that the status shows no errors and that all the appwrite/appwrite containers have the same version.
Our reasoning: pulling an image is not the same as being upgraded. Check that the containers actually run the tag you intended after docker compose up -d, and look at the version in the console.
What Appwrite says it changed
- The root fix: services no longer follow links that customer code plants, and skip any file from a runtime or build that is not a plain file.
- Confinement: a mandatory security profile on every container that runs customer code, and on the services around it, so no process can read another process's configuration.
- Unprivileged code on separate machines: in every region, functions and sites run as a restricted user, and platform services no longer share machines with customer code.
- Separate credentials per service: secrets that several services shared were split. In all six regions the main services, caches, database proxies and network tunnels no longer carry credentials for the system that runs the workloads.
- New signing and encryption keys: the old version is refused everywhere, and stored data is being re-encrypted.
- Faster rotation: the main internal secrets accept an old and a new version side by side.
- Blocking a project now also stops copies of its functions and sites that are already running.
What this means for your own platform
This part is our reasoning, not Appwrite's, and applies to anything that runs other people's code: serverless functions, CI runners, build agents, plugin systems.
- A sandbox is one layer. The escape here was a file-handling mistake in a service next to the sandbox, not in the sandbox itself. Treat files that tenant code can write as hostile input: no following links, no trusting anything that is not a plain file.
- Credentials decide the blast radius. A single token that reads every tenant's configuration turns one escape into a platform-wide exposure. Appwrite's own fix list agrees: per-service credentials, and no workload-system credentials in front-line services.
- Separate machines for tenant code and control plane, so a process that escapes finds little next door.
- Rotation has to be a normal operation. Appwrite now supports old and new secret versions side by side. If your emergency rotation is a manual night job, the first real incident will find the gaps.
- Audit logs are evidence. The one fact Appwrite cannot establish is the one a missing log hides. Keep the logs of the systems your credentials touch, long enough to cover an incident window, and know which of them record reads.
- Keep the incident layers apart. Here a customer's own weak application, a runtime flaw, a storage API flaw and a potentially exposed token are four separate things. Merging them into "the platform was hacked" makes remediation sloppy.
Common traps
- "We were not named in the attack, so we are fine." Appwrite says the attacker's activity was aimed at a single customer. The notification is about what was reachable, not about what was done to you.
- "We changed the variable, so we are done." Running copies keep the old value until you redeploy, and the old secret keeps working until you revoke it at the issuer.
- "We deleted the old Appwrite key, so the other secrets are safe." The listed variables mostly belong to other services. Each one needs rotating where it was issued.
- "The upgrade finished, so the executor is fixed." Check the running versions. On a multi-tenant instance, also rotate
_APP_EXECUTOR_SECRET.
What we have not verified
- Appwrite's forensics. We cannot check the timeline, the list of credentials used, the claim that no other customer's files were read, or the conclusion drawn from the records that remained.
- Whether the old token was used. Nobody outside Appwrite can say. Appwrite says it cannot rule it out.
- Whether secrets under non-obvious names were notified. Appwrite describes name-based criteria. How it handled the edge cases is not stated.
- The upgrade steps. We did not run the upgrade or the executor rotation. The commands are the documented form.
- Any other platform. Nothing here says the same flaw exists elsewhere.
If you hit something different from this page, tell us at info@opsbreakfix.com and we will correct it.
Related guides
- Manage CI variables and secrets safely: scoping and storing the kind of secrets that sit in function and site variables, so a rotation touches fewer places.
- Use .gitignore and keep secrets out of Git: the other place a secret you must now rotate may also be hiding.
- Run an AI coding agent against infrastructure safely: the same idea of narrow, separate credentials per identity.
- Node2Shell (CVE-2026-111497): Patch and Verify: the other November incident where the fix is only real once the running process is replaced.
Sources
More from the blog
- wfx GitHub Actions Stealer: Check Repos, Cloud Roles · News, 2026-11-12
- Microsoft 365 Outage 12 Nov 2026: What To Do · News, 2026-11-12
- N-able N-central Offline: What MSPs Should Do Now · News, 2026-11-10
This article is educational information, not incident-response or legal advice. Verify package status with your operating system, hosting, or runtime vendor.