/

CVE-2026-41491

Severity:

HIGH RISK

(8.1)

Access Control Bypass via Path Normalization in Dapr

CVE-2026-41491

Analyzed

Vulnerability type

Category:

Access Control Bypass via Path Normalization

CWE:

CWE-22, CWE-284

Impact:

Unauthorized Service Invocation and Access Control Bypass

Severity:

HIGH RISK

(8.1)

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

Dapr's service invocation ACL logic can be bypassed by crafting method paths that use reserved URL characters and path traversal sequences.

Because the ACL engine and the dispatch layer normalize paths differently, Dapr may authorize one path while the target application actually receives another, enabling unauthorized access to protected methods or APIs.

Affected context

This vulnerability affects Dapr-based distributed applications that:

  • Use Dapr's service invocation feature to call methods on downstream services.
  • Rely on Dapr Access Control Lists (ACLs) to restrict which methods or routes can be invoked.
  • Run vulnerable Dapr runtime versions where path normalization in the ACL layer does not match normalization in the dispatch layer.

It is most relevant in deployments where untrusted or semi-trusted clients can send invocation requests that include path components or method names controlled by the requester.

Exploit preconditions

  • Attack surface: Dapr service invocation endpoints exposed over HTTP/gRPC from sidecars or ingress-facing gateways.
  • Required access: Ability to send crafted service invocation requests to a Dapr sidecar or gateway that enforces ACLs.
  • Trigger point: The attacker supplies a method path containing reserved URL characters and/or path traversal segments (e.g., encoded separators, .. components).
  • Why exploitation is possible: The ACL component and the dispatch layer normalize and interpret method paths differently. As a result, the ACL may evaluate a "sanitized" or altered path as allowed, while the dispatch layer routes the original or differently-normalized path to a protected method that should have been denied.

Why this happens

The underlying issue is a mismatch in path normalization between the authorization layer and the request routing layer, mapping to:

  • CWE-284: Improper Access Control, because enforcement decisions are made on a representation of the path that does not match what the application ultimately receives.
  • CWE-22: Path Traversal, because use of traversal sequences (../, equivalent encoded characters, and reserved URL characters) changes the effective target path after ACL evaluation.

Conceptually, the ACL subsystem performs its own normalization or interpretation of the method path independently. The dispatch layer then re-parses or normalizes the path differently, potentially resolving traversal segments or reserved characters into a route that the ACL never intended to permit. This gap between policy evaluation and actual routing creates an authorization bypass.

Potential impact

  • Invocation of methods or endpoints that were intended to be blocked by ACL policies.
  • Access to sensitive internal APIs or administrative operations exposed through Dapr service invocation.
  • Bypassing application-layer authorization checks that assume Dapr ACLs are correctly enforcing allowed method paths.
  • Lateral movement between services by abusing trusted Dapr sidecars to reach otherwise restricted functionality.
  • Potential data exposure, corruption, or unexpected state changes in downstream microservices.

General mitigation guidance

Long-term mitigation focuses on aligning path handling and tightening trust around method paths:

  • Ensure that access control decisions are based on exactly the same normalized path that the dispatch layer uses, avoiding independent parsing or normalization logic.
  • Apply strict whitelisting/allowlisting of method paths or route patterns instead of relying on broad or ambiguous path rules.
  • Normalize and canonicalize method paths at a single, central point in the request lifecycle, and use that canonical form consistently for both routing and authorization.
  • Avoid depending solely on Dapr ACLs for critical authorization; combine them with in-service authorization checks that validate the effective route and caller identity.
  • Reduce exposure of service invocation interfaces so that only trusted frontends or gateways can send arbitrary method paths, and enforce least privilege on inter-service calls.

How teams detect issues like this

Effective detection involves both code and configuration analysis:

  • Configuration review: Examine Dapr configuration files and ACL rules for patterns that rely on path prefixes, wildcards, or loosely defined method paths that could be manipulated with traversal sequences or encoded characters.
  • Static analysis / policy checks: Use linters or policy-as-code tools (e.g., OPA, custom CI checks) to flag ACL definitions that do not normalize paths consistently, or that fail to constrain method names to well-defined patterns.
  • Logging and monitoring: Enable detailed logging of both the raw method path received and the canonical path used for routing and authorization; alert on discrepancies, suspicious traversal patterns, or repeated access attempts to blocked methods.
  • Dynamic testing: Incorporate security tests that send crafted method paths with reserved URL characters and .. segments to verify that blocked endpoints remain inaccessible.
  • Automated review tools: Integrate automated configuration scanners and API security tools that understand Dapr service invocation semantics to catch potentially bypassable ACL configurations early in the deployment pipeline.

Sources

SourceLink
github.comgithub.com/dapr/dapr/pull/9589
github.comgithub.com/dapr/dapr/security/advisories/GHSA-85gx-3qv6-4463

Frequently asked

questions

It can be, depending on your architecture. If external or semi-trusted clients can directly or indirectly send service invocation requests to Dapr sidecars or gateways, they may exploit this path normalization issue to invoke protected methods.

An attacker needs the ability to submit crafted service invocation requests that include custom method paths. They typically do not need local code execution on the service; network-level access to the invocation interface and knowledge of method paths are sufficient.

The safest pattern is to normalize and canonicalize request paths once and use that canonical form consistently for both routing and authorization. Access control logic should not interpret paths differently from the dispatch layer, and policies should be expressed in terms of the canonical path.

Prevent them by designing authorization around canonical resources rather than raw user input, centralizing path handling, and performing security reviews specifically focused on path normalization and traversal. Combine strict, allowlist-based ACLs with defense-in-depth checks inside services, and include targeted tests for encoded characters and traversal sequences in your regular security testing.

Find out what's already
exploitable in your codebase.