/

CVE-2026-41074

Severity:

HIGH RISK

(7.1)

CSRF in RT Issue Tracking System

CVE-2026-41074

Deferred

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-352

Impact:

Unauthorized state-changing actions via a victim's authenticated session

Severity:

HIGH RISK

(7.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

RT versions 6.0.0 through 6.0.2 contain a Cross-Site Request Forgery (CSRF) vulnerability that allows attackers to trigger state-changing actions in RT on behalf of a logged-in user.

If a victim is authenticated to RT and visits a malicious web page, crafted requests can be sent to RT using the victim's session, potentially altering tickets, configurations, or other sensitive data without their knowledge.

Affected context

This vulnerability affects RT deployments where users access the web interface via a browser and remain logged in while browsing other websites.

It is most relevant in environments where:

  • RT accepts state-changing HTTP requests (e.g., ticket updates, configuration changes) without robust CSRF protections.
  • Users commonly keep RT open in a browser tab while performing other web activities.
  • Network boundaries (e.g., VPN-only access) are relied upon more than application-layer protections.

The issue does not require direct network access to RT by the attacker, only the victim's browser access with an active session.

Exploit preconditions

  • Attack surface: RT web interface endpoints that perform state-changing operations (e.g., POST/GET actions that modify tickets, user settings, or configuration).
  • Required access: The attacker does not need direct authentication to RT; they must induce an already authenticated RT user to load attacker-controlled content (web page, HTML email, ad frame, etc.).
  • Trigger point: The victim's browser automatically issues forged HTTP requests to RT while the victim is logged in, using existing cookies/session tokens.
  • Why exploitation is possible: State-changing routes in RT either lack CSRF tokens, do not enforce them consistently, or accept requests based solely on the presence of a valid session cookie, allowing cross-origin web pages to submit unintended actions.

Why this happens

The root cause aligns with CWE-352: Cross-Site Request Forgery (CSRF), where the application trusts authenticated requests solely on the basis of session credentials (e.g., cookies), without verifying that the request originated from legitimate RT pages.

When a logged-in user visits a malicious site, that site can embed forms, images, scripts, or XHR/fetch requests that target RT endpoints.

Because RT's state-changing endpoints in affected versions do not consistently require a per-request, origin-bound CSRF token or equivalent anti-CSRF mechanism, the browser includes the user's RT session cookie and the application treats the forged request as genuine.

This is an architectural/validation flaw, not a bug in a specific line of business logic, and can surface whenever authentication is not coupled with request origin verification.

Potential impact

  • Attackers may cause unauthorized ticket updates (status changes, comments, ownership reassignment).
  • Attacker-controlled content or instructions could be injected into ticket comments or fields via the victim's identity.
  • User profile or preference changes could be made on behalf of the victim.
  • Administrative or workflow configuration may be altered if the victim has elevated privileges.
  • Incident response and audit trails may be skewed because malicious actions appear to come from legitimate users.

General mitigation guidance

Effective mitigation centers on consistently binding state-changing actions to a trusted origin and user intent:

  • Implement robust CSRF protection for all state-changing endpoints, typically via per-request, cryptographically strong anti-CSRF tokens tied to the user session and validated server-side.
  • Prefer same-site cookies (SameSite=Lax or SameSite=Strict) to limit which cross-site requests automatically include authentication cookies, while ensuring compatibility with legitimate flows.
  • Enforce strict HTTP method use: require POST/PUT/DELETE for state changes and avoid side effects in GET requests.
  • Validate Origin and/or Referer headers for sensitive operations where feasible, rejecting requests from unexpected origins.
  • Encourage least-privilege role design so that routine user sessions cannot perform high-impact administrative actions.
  • Design UI workflows so that sensitive actions (e.g., configuration changes) require explicit user interaction, such as confirming forms that incorporate valid CSRF tokens.

How teams detect issues like this

To detect and monitor for similar CSRF risks:

  • Use static analysis or linting rules to flag state-changing controller actions or routes that lack CSRF protection annotations/middleware.
  • During security reviews, trace all endpoints that modify data to verify presence and enforcement of CSRF tokens and correct HTTP methods.
  • Inspect code for patterns where authentication checks are present but no additional request-origin or CSRF validation is performed.
  • Configure web application firewalls (WAFs) or reverse proxies to enforce method constraints and optionally validate origin headers for critical endpoints.
  • Incorporate automated security testing that runs CSRF checks against authenticated workflows, ensuring coverage for both user and admin functionalities.

Sources

SourceLink
github.comgithub.com/bestpractical/rt/releases/tag/rt-6.0.3
github.comgithub.com/bestpractical/rt/security/advisories/GHSA-265j-qx4w-256j

Frequently asked

questions

It is broadly exploitable if attackers can reach users who are logged into RT. Any scenario where users visit external websites, read HTML emails, or interact with third-party content while authenticated can be leveraged to trigger forged requests.

No. The attacker relies on the victim's authenticated browser session. The attacker needs to get an authenticated RT user to visit a malicious page, but does not need their credentials or direct network access to RT.

Apply consistent CSRF protection to all state-changing routes: require and validate anti-CSRF tokens, restrict side effects to non-GET methods, and pair these controls with secure cookie attributes (e.g., SameSite) and, where appropriate, origin/referrer validation.

Adopt a framework-level CSRF defense that is enabled by default for all mutating actions, enforce secure session cookie configurations, and include CSRF checks in code review and automated testing. Make CSRF protection a standard part of route/controller implementation guidelines so that new features inherit secure patterns automatically.

Find out what's already
exploitable in your codebase.