CVE-2026-70489: Open WebUI: Instance-wide stall via automation recurrence rules that force multi-second parsing

_parse_rule in backend/open_webui/utils/automations.py anchors minutely and hourly rules at 2000-01-01 so that "every 5 minutes" lands on clock boundaries. It then lets the recurrence library walk forward one interval at a time to find the next run. That is about a quarter-century of occurrences, computed synchronously on the event loop that also serves the scheduler, HTTP and WebSocket traffic. Nothing bounds or offloads the walk.

Measured on 0.10.2: RRULE:FREQ=MINUTELY takes 18,880 ms of blocking CPU, adding BYSECOND=0,1,...,9 takes 64,236 ms, and a DTSTART:20000101T000000 variant takes 26,237 ms. FREQ=HOURLY costs 339 ms and is not useful alone.

The damage does not end at creation. Once the automation is stored, the scheduler recomputes the next run on each poll, every 10 seconds by default. The instance stays wedged rather than recovering. UVICORN_WORKERS defaults to 1, so no second worker absorbs the stall.

The attacker must be able to create an automation. USER_PERMISSIONS_FEATURES_AUTOMATIONS is false by default, so on a default deployment only an admin can. Ordinary users can once the feature is granted, which is the normal way to make it usable.

Open WebUI >= 0.9.0, < 0.11.0, the range since automations shipped. Instances where only admins can create automations are exposed to an admin only. Instances that granted the automations feature to ordinary users are exposed to those users. Check the version:

pip show open-webui

The permission to check is USER_PERMISSIONS_FEATURES_AUTOMATIONS in your environment or the admin permissions page.

Upgrade to 0.11.0:

pip install --upgrade open-webui==0.11.0

Sub-daily rules are now anchored to the current clock, and a caller-supplied DTSTART is honoured only when the number of occurrences it implies stays under a fixed bound. The same rules now cost under a millisecond. No configuration change is needed. If an instance is already wedged by a stored automation, the sources do not describe a recovery step beyond upgrading. Not granting the automations feature to ordinary users limits who can trigger it.

Signs are sudden unresponsiveness of all HTTP and WebSocket traffic, a single CPU core pinned at 100%, and the problem returning every ~10 seconds after restarts. Review the automations table for FREQ=MINUTELY rules with no DTSTART or a DTSTART far in the past, and find who created them. Look in access logs for automation create, update or toggle calls just before the slowdown began.

Summary

In every affected release, automation recurrence parsing anchors minutely and hourly rules at a fixed date of 2000-01-01 and then walks forward one interval at a time to find the next run. A single FREQ=MINUTELY rule therefore enumerates roughly a quarter-century of occurrences, synchronously, on the event loop that also serves the scheduler, HTTP and WebSocket traffic. Nothing bounds the walk, and nothing moves it off the loop.

Preconditions

Any user who can create an automation. USER_PERMISSIONS_FEATURES_AUTOMATIONS defaults to false, so on a default deployment only an admin can reach the create path; it becomes reachable by ordinary users on any deployment that has granted the automations feature, which is the normal way to make the feature usable. UVICORN_WORKERS defaults to 1, so there is no second worker to absorb the stall. The rule needs no unusual syntax: FREQ=MINUTELY with no DTSTART, or with a DTSTART set well in the past, is enough.

Impact

Availability, against every other user of the instance. One evaluation of RRULE:FREQ=MINUTELY takes 18.9 s of blocking CPU; adding a ten-value BYSECOND list multiplies the walk and takes 64.2 s. FREQ=HOURLY costs 0.34 s and is not materially exploitable on its own. The cost does not stop at creation: once the automation is stored, the scheduler recomputes the next run for every claimed row on each poll, so the same walk repeats on a default 10 s interval and the instance stays wedged rather than recovering. Instances that have not enabled the automations feature for non-admin users are exposed only to an admin doing this.

Fix

Fixed in 0.11.0. Sub-daily rules are now anchored to the current clock instead of the year-2000 date, so the walk starts at the next occurrence rather than a quarter-century behind it. A caller-supplied DTSTART is honoured only when the number of occurrences it implies stays under a fixed bound, and is otherwise replaced by the clock-aligned anchor. The same rules that cost 18.9 s and 64.2 s now cost under a millisecond. Upgrading fully resolves the issue, no configuration change is required.

Root cause

Affected component: backend/open_webui/utils/automations.py, _parse_rule, reached from the automation create, update and toggle handlers in backend/open_webui/routers/automations.py and from the scheduler's claim path in backend/open_webui/models/automations.py. Affected setup: every build from 0.9.0 onward, since that is when the automations feature shipped.

The fixed anchor existed to make sub-daily intervals snap to clock boundaries, so that "every 5 minutes" lands on :00, :05, :10 rather than drifting from whenever the automation happened to be created. Snapping only needs a reference point of the right phase, but the implementation used a literal far-past date as that reference and left the recurrence library to walk forward from it. The distance between the anchor and the present is therefore attacker-influenced work that grows with real time, and it was never treated as a cost that needed a bound or a thread.

Proof of concept

Measured cost of a single next-run computation against the shipped 0.10.2 parser:

| rule | cost |
| `RRULE:FREQ=MINUTELY` | 18,880 ms |
| `RRULE:FREQ=MINUTELY;BYSECOND=0,1,2,3,4,5,6,7,8,9` | 64,236 ms |
| `DTSTART:20000101T000000` + `RRULE:FREQ=MINUTELY` | 26,237 ms |
| `RRULE:FREQ=HOURLY` | 339 ms |

Measured at function level deliberately. Persisting such an automation has the scheduler repeat the walk on every poll and wedge the instance indefinitely, which is the actual impact but makes a live end-to-end run destructive to the test instance.

Credits

Reported by @Classic298.