Summary
EasyAdmin can bypass path-based authorization rules when a backend request causes the framework to replace the originally selected controller with one identified by an unvalidated routeName parameter. A low-privilege backend user who can access an EasyAdmin URL and knows a protected route name may invoke that route's controller without the expected path-based check.
Affected context
The issue occurs in EasyAdmin applications that use the affected dashboard routing and custom actions linked through route names. Symfony's firewall evaluates access_control rules against the original dashboard URL before EasyAdmin swaps in the controller associated with routeName. Consequently, path-based rules for the replacement route may not be evaluated. Controller- level authorization checks such as IsGranted or denyAccessUnlessGranted can still protect the target action.
Exploit preconditions
- Attack surface: EasyAdmin backend HTTP requests - Required access: A low-privilege authenticated user who can reach an
EasyAdmin URL
- Trigger point: Controller replacement during the kernel.controller event - Required knowledge: The name of a target route exposed through the
application's routing configuration
- Why exploitation is possible: The routeName value selects a different
controller after the firewall has evaluated the original path, while the
replacement route's path-based access rule is not re-evaluated
Why this happens
The underlying bug is an authorization-context mismatch caused by changing the controller after path-based security decisions have already been made. EasyAdmin accepted a routeName value without adequately constraining the controller-selection operation, allowing a request authorized for one dashboard path to execute another route's controller. This represents missing authorization enforcement under CWE-862 and may also involve incorrect authorization decisions under CWE-863 and identifier-based access control concerns under CWE-639.
Potential impact
- A low-privilege user may access administrative actions protected only by path-based rules.
- An attacker could invoke controllers outside the user's intended authorization scope.
- Sensitive administrative data may be disclosed or modified.
- Protected operations could be performed without the expected access-control decision.
General mitigation guidance
Mitigation generally focuses on keeping authorization decisions bound to the final controller and validated route context. Secure-by-default designs can restrict custom action targets to explicitly registered, expected routes and avoid trusting arbitrary route identifiers from requests. Authorization should be enforced at the controller or business-operation boundary, using deny-by-default policies and explicit privilege checks. Applications can also minimize backend privileges, separate administrative capabilities by role, and ensure that routing or controller substitutions trigger complete authorization evaluation rather than relying only on the original request path.
How teams detect issues like this
Detection can include static analysis and code review for controller replacement after firewall authorization, request parameters that select routes or handlers, and custom actions that use unvalidated route names. Test suites should compare authorization outcomes for the original dashboard path and the final controller, including low-privilege roles and protected routes. Policy enforcement can require explicit controller-level authorization for administrative operations and can flag dynamic route resolution in security-sensitive request flows. Automated application-security review tools may help identify these patterns.

