Skip to main content

Open WebUI CVE-2026-70489

| EUVDEUVD-2026-52917 MEDIUM
Uncontrolled Resource Consumption (CWE-400)
2026-08-04 https://github.com/open-webui/open-webui GHSA-73cq-mcgh-379c
6.5
CVSS 3.1 · Vendor: https://github.com/open-webui/open-webui
Share

Severity by source

Vendor (https://github.com/open-webui/open-webui) PRIMARY
6.5 MEDIUM
AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
vuln.today AI
6.5 MEDIUM

AV:N and PR:L are accurate - the endpoint is network-reachable and requires an authenticated low-privilege user; A:H captures the persistent, instance-wide stall.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/open-webui/open-webui).

CVSS VectorVendor: https://github.com/open-webui/open-webui

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Source Code Evidence Fetched
Aug 04, 2026 - 21:04 vuln.today
Analysis Generated
Aug 04, 2026 - 21:04 vuln.today

DescriptionCVE.org

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:

rulecost
RRULE:FREQ=MINUTELY18,880 ms
RRULE:FREQ=MINUTELY;BYSECOND=0,1,2,3,4,5,6,7,8,964,236 ms
DTSTART:20000101T000000 + RRULE:FREQ=MINUTELY26,237 ms
RRULE:FREQ=HOURLY339 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.

AnalysisAI

Open WebUI versions 0.9.0 through 0.10.x expose an instance-wide availability collapse through unbounded iCalendar recurrence rule parsing in the automation scheduler. The _parse_rule function in backend/open_webui/utils/automations.py anchors MINUTELY and HOURLY rules to a hardcoded 2000-01-01 epoch and iterates forward one interval at a time on the synchronous ASGI event loop - a single RRULE:FREQ=MINUTELY rule consumes approximately 18.9 seconds of blocking CPU, denying service to every concurrent user. Critically, the stall is not transient: once the automation is stored, the scheduler recomputes the next-run value on every 10-second poll, permanently wedging the instance until it is restarted or the automation is surgically removed. No public exploit identified at time of analysis, though the vendor advisory includes precise proof-of-concept timing measurements that make the attack trivially reproducible.

Technical ContextAI

Open WebUI is a Python/FastAPI ASGI web application served by Uvicorn, using a shared event loop for HTTP, WebSocket, and internal scheduler traffic. Automation scheduling relies on iCalendar RRULE syntax parsed via a recurrence library (python-dateutil rrulestr). CWE-400 (Uncontrolled Resource Consumption) captures the root cause precisely: the fixed DTSTART anchor of 2000-01-01 forces the library to enumerate approximately 25 years of minutely occurrences - on the order of 13 million steps - to find the single next scheduled run. Because UVICORN_WORKERS defaults to 1, there is no second worker process to absorb the stall. The vulnerability exists in three code paths: the automation create, update, and toggle handlers in backend/open_webui/routers/automations.py, and the scheduler's claim path in backend/open_webui/models/automations.py, all of which call the same _parse_rule function. The affected CPE is pkg:pip/open-webui, versions >= 0.9.0 (when the automations feature shipped) through < 0.11.0.

RemediationAI

Upgrade to Open WebUI 0.11.0, released at https://github.com/open-webui/open-webui/releases/tag/v0.11.0 (patch commit: c4ae8c86786fed521960466f6d8eef8af22c2946). The fix anchors sub-daily rules to the current clock rather than the 2000-01-01 epoch and enforces an occurrence-count bound on any caller-supplied DTSTART, reducing parsing cost from tens of seconds to under one millisecond with no configuration change required. If immediate upgrade is not feasible, set USER_PERMISSIONS_FEATURES_AUTOMATIONS=false to restrict automation creation to administrators only - this narrows the attack surface to trusted accounts but does not eliminate it, since a malicious or compromised admin can still trigger the stall. Setting UVICORN_WORKERS to a value greater than 1 would allow other worker processes to continue serving traffic during a stall, but this does not prevent the stall itself, does not stop the scheduler from re-triggering the blocking computation on every 10-second poll, and requires infrastructure-level changes. Neither workaround substitutes for patching.

Share

CVE-2026-70489 vulnerability details – vuln.today

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy