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.

