/

CVE-2026-34222

Severity:

HIGH RISK

(7.7)

Broken Access Control in Open WebUI Tool Values

CVE-2026-34222

Analyzed

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-285

Impact:

Unauthorized Access and Manipulation of Tool Configuration or Data

Severity:

HIGH RISK

(7.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Open WebUI, a self-hosted offline AI platform, contains a broken access control issue affecting how tool values are accessed and manipulated prior to version 0.8.11.

Under certain conditions, users may be able to view or influence tool-related data or behavior beyond their intended permissions, potentially impacting confidentiality, integrity, or stability of the AI workflows.

Affected context

This vulnerability appears in Open WebUI deployments using tools or extensions whose values are stored and processed by the application.

It is relevant where multiple users, roles, or automation agents share the same Open WebUI instance and rely on permission boundaries for tool configuration or invocation.

The risk is heightened in environments where tool values can impact AI behavior, connect to external systems, or influence downstream automation, particularly if administrators and regular users share the same instance without strong isolation.

Exploit preconditions

  • Attack surface: Web-based Open WebUI interface and any exposed APIs handling tool values.
  • Required access: Valid access to the Open WebUI instance (e.g., authenticated user or network access where anonymous usage is allowed), but not necessarily elevated privileges.
  • Trigger point: Interactions that read, set, or execute tools and their associated values (e.g., modifying parameters, loading saved configurations, or triggering tools in sessions).
  • Why exploitation is possible: Authorization checks around tool values are incomplete or inconsistently enforced, allowing a user or session to access or manipulate tool-related data that should be restricted to other roles or users.

Why this happens

The core issue maps to CWE-285: Improper Authorization (Broken Access Control).

At a high level, the application fails to correctly verify whether a requesting user or context is allowed to access or modify specific tool values.

This can arise from:

  • Relying on client-side assumptions about which tool values a user should see.
  • Applying authorization at a coarse-grained level (e.g., "logged in vs. not") rather than at the level of individual tools or tool instances.
  • Reusing endpoints or data models without re-checking that the current user owns or is permitted to operate on the referenced tool values.

The bug class is an authorization gap: security-relevant decisions are either missing or applied in the wrong place, enabling unintended access paths.

Potential impact

  • Unauthorized viewing of tool configurations, including parameters that may encode sensitive information (e.g., endpoints, tokens, or internal references).
  • Unauthorized modification of tool values, altering how AI workflows behave for other users or system-wide.
  • Indirect data exposure if tool values influence prompts, outputs, or log content visible across users.
  • Disruption of automated processes or integrations that depend on stable, trusted tool configurations.
  • Potential privilege-like escalation if a user can bind tools to resources or backends they should not control.

General mitigation guidance

Addressing this class of vulnerability typically involves strengthening authorization logic around configuration objects and tool-related operations:

  • Apply server-side access control checks on every operation that reads, writes, or executes tool values, ensuring the current user or context is explicitly authorized for the specific tool instance.
  • Adopt least-privilege defaults for tools and configurations so new tools are not accessible globally unless explicitly shared or granted.
  • Isolate sensitive tool values (such as secrets or powerful configuration options) behind additional privilege levels or separate storage mechanisms with stricter policies.
  • Introduce ownership models for tool configurations, where each tool value set has a clear owner and access policy, and all accesses are evaluated against that policy.
  • Avoid trusting client-side indications of permissions, such as hidden UI elements, and instead enforce policy exclusively on the server.
  • Segment environments by user role or team where feasible, reducing the blast radius of misconfigurations in shared deployments.

These patterns help ensure that even if tools are widely used, access to their underlying values is tightly controlled and auditable.

How teams detect issues like this

Organizations can detect and monitor for this class of issue by combining code-centric and behavior-centric techniques:

  • Static analysis and code review:
  • Flag endpoints and handlers dealing with tool values that do not perform explicit authorization checks.
  • Review controller and API methods that accept resource identifiers (e.g., tool IDs) to ensure they verify ownership or permission rather than just existence.
  • Look for shared global stores of configuration data accessed without user scoping or tenant separation.
  • Security-focused testing:
  • Perform authorization testing using accounts with different roles to verify that tool values cannot be read or modified across boundaries.
  • Use automated test suites or dynamic analysis tools to fuzz access to tool endpoints with varied identifiers.
  • Runtime monitoring and logging:
  • Log access to sensitive or shared tool values, including user identity, resource identifiers, and operation type (read/write/execute).
  • Set up anomaly detection to identify unusual patterns, such as a single low-privilege account accessing multiple users' tool configurations.
  • Policy enforcement in CI/CD:
  • Enforce development guidelines requiring explicit permission checks for all tool-related endpoints and reject changes that bypass standard authorization helpers.

Sources

SourceLink
github.comgithub.com/open-webui/open-webui/releases/tag/v0.8.11
github.comgithub.com/open-webui/open-webui/security/advisories/GHSA-7429-hxcv-268m
seclists.orgseclists.org/fulldisclosure/2026/Apr/4

Frequently asked

questions

It can be exploited remotely if the Open WebUI instance is accessible over the network and an attacker can obtain access to an account or use any anonymous/guest capabilities. The vulnerability does not inherently require local system access.

Typically, an attacker needs at least some level of application access (e.g., a normal user account or guest access if enabled). The broken access control then allows that user to access tool values beyond what their role or identity should normally permit.

The safest pattern is to implement strict, server-side authorization checks for every operation involving tool values, based on resource ownership and explicit permissions. Centralize authorization logic so all tool-related endpoints pass through the same permission enforcement layer.

Preventive measures include designing features with "deny by default" access policies, consistently using authorization middleware/helpers, performing regular authorization testing in QA, and adopting coding standards that forbid direct access to shared configuration objects without passing through a vetted access control layer.

Find out what's already
exploitable in your codebase.