Summary
A logic flaw in YetAnotherForum.NET (YAF.NET) allows certain admin-only POST handlers to execute their side effects before the framework rewrites the response to a redirect, effectively bypassing intended authorization.
In the most severe case, the /Admin/RunSql endpoint accepts arbitrary SQL from a low-privileged user and passes it directly to the database layer, enabling arbitrary SQL execution under the application's database account.
Affected context
This vulnerability affects YAF.NET deployments where:
- The application is running a version prior to 4.0.5.
- Low-privileged or regular authenticated users can reach admin POST endpoints such as /Admin/RunSql.
- Result filters (e.g., ResultFilterAttribute) are used to enforce redirects or access control after handler execution.
The flaw arises specifically in "OnPost..." handlers whose side effects (such as executing SQL) run before the ResultFilterAttribute rewrites the HTTP response to a 302 redirect, allowing unauthorized logic to be performed despite the apparent redirect.
Exploit preconditions
- Attack surface: HTTP POST requests to admin controller endpoints (e.g., /Admin/RunSql).
- Required access: Ability for a low-privileged, authenticated user (or any user who can reach the admin POST route) to send crafted POST requests.
- Trigger point: Invocation of an admin OnPost… handler, such as
OnPostRunQuery, which binds POST body data and performs side effects before the ResultFilterAttribute is applied. - Why exploitation is possible: The access control/redirect logic is implemented via a response filter that runs after the handler method. The handler executes privileged operations (calling
IDbAccess.RunSqlwith user-supplied SQL) without performing its own authorization check, creating a window where unauthorized users can trigger admin-only behavior.
Why this happens
The core issue is a misordering of authorization and business logic in the request pipeline, aligning with CWE-841: Improper Enforcement of Behavioral Workflow.
In YAF.NET, admin POST handlers (OnPost… methods) execute their side effects before the ResultFilterAttribute rewrites the response to a 302 redirect, which is intended to enforce a specific navigation or access pattern. For /Admin/RunSql, the OnPostRunQuery method binds the Editor field from the POST body and passes it directly to IDbAccess.RunSql without verifying that the caller is actually an administrator. This design trusts that the result filter will handle access or redirection after the fact, but because the handler has already run, an attacker can exploit this to perform actions that should be restricted.
The SQL being run is arbitrary and user controlled, mapping to CWE-89: SQL Injection in the sense of executing unvalidated SQL statements supplied by the user. However, the distinguishing flaw is not a classic injection into a parameterized query, but the choice to expose a raw SQL execution capability without properly enforcing role checks before invocation.
Potential impact
- Attackers could execute arbitrary SQL commands against the forum database.
- Attackers could read, modify, or delete forum data, including posts, users, and configuration records.
- Attackers could create or escalate user accounts by directly manipulating user tables.
- Attackers could tamper with application configuration stored in the database, potentially enabling further compromise.
- Attackers could cause denial of service by dropping tables, corrupting data, or running expensive queries.
General mitigation guidance
Effective mitigation revolves around enforcing authorization before executing privileged operations and eliminating unsafe raw SQL entry points.
Recommended defensive patterns include:
- Ensure that all admin or high-privilege handlers perform explicit authorization checks at the beginning of the handler method, independent of filters that only modify the response.
- Avoid architectural designs where security controls rely solely on response filters or redirects; access control should short-circuit request processing before side effects occur.
- Restrict or remove features that accept raw SQL from users; when such functionality is unavoidable (e.g., for internal tools), strictly limit it to trusted roles, require strong authentication, and isolate it from the public site.
- Encapsulate database access behind strongly-typed repository or service methods instead of exposing low-level, arbitrary SQL execution APIs to web handlers.
- Apply least-privilege principles to the database credentials used by the application so that even if an endpoint is misused, the damage is constrained (e.g., no ability to drop schemas or modify security-critical tables).
- Adopt defensive design reviews for endpoints with administrative capabilities, ensuring that all security decisions are made early in the control flow.
How teams detect issues like this
Organizations can detect and monitor for this class of issue using a combination of review and tooling:
- Static analysis and code scanning:
- Flag controller or page handlers that call low-level data access methods like
RunSql,ExecuteNonQuery, orExecuteScalarusing user-supplied input. - Detect handlers that skip or defer authorization checks, especially where access control is only applied via filters or attributes that act after handler logic.
- Identify any method that exposes a "run arbitrary SQL" capability and verify it is only callable by administrative roles.
- Code review practices:
- During peer review, trace the request lifecycle end-to-end to confirm that access control is enforced before any side effects or database operations.
- Look for reliance on redirects or
ResultFilterAttribute-based logic to "hide" sensitive functionality instead of enforcing hard access control. - Runtime monitoring:
- Configure application logs to capture calls to generic SQL execution APIs, along with the calling controller and user identity, and alert on unexpected usage by non-admin accounts.
- Use web application firewalls or application-level logging to detect suspicious POST traffic to admin endpoints from untrusted users.
- Automated tools:
- Integrate SAST/DAST tools that understand ASP.NET MVC or Razor Pages lifecycles and can flag dangerous combinations of unsafe data access and missing authorization in handlers.

