/

CVE-2026-41189

Severity:

HIGH RISK

(7.1)

Authorization Bypass / Access Control in FreeScout Customer

CVE-2026-41189

Deferred

Vulnerability type

Category:

Authorization Bypass / Access Control

CWE:

CWE-863

Impact:

Unauthorized Data Modification and Information Exposure

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

A missing authorization check in FreeScout's customer-thread editing logic allows users with mailbox access to edit customer-authored threads in conversations they are not allowed to view.

Under certain permission configurations, this discrepancy between thread and conversation policies can expose sensitive customer communication to unauthorized modification.

Affected context

This vulnerability appears in FreeScout deployments that:

  • Use mailbox- and conversation-based access controls to restrict who can view specific conversations.
  • Rely on ConversationPolicy to enforce "assigned-only" or similar restrictions on conversation visibility.
  • Allow users with general mailbox access who are not necessarily assigned to every conversation.

In this context, ThreadPolicy::edit() only checks mailbox access and omits the stricter conversation-level authorization, creating a mismatch between what a user can see and what they can edit.

Exploit preconditions

  • Attack surface: FreeScout web application, specifically customer thread editing endpoints.
  • Required access: Authenticated FreeScout user with access to the relevant mailbox but without permission to view certain conversations due to conversation-level restrictions.
  • Trigger point: The attacker navigates directly to or otherwise triggers the customer-thread edit functionality for a thread inside a conversation they cannot normally open.
  • Why exploitation is possible: The edit check is enforced using ThreadPolicy::edit(), which validates mailbox access only and does not re-apply the stricter "assigned-only" or visibility rules defined in ConversationPolicy, resulting in a missing authorization check at the thread level.

Why this happens

The root cause is an inconsistent application of authorization policies between different but related resources.

While ConversationPolicy enforces "assigned-only" or similar constraints on viewing conversations, ThreadPolicy::edit() only verifies mailbox-level access when editing customer-authored threads.

This divergence embodies CWE-863: Incorrect Authorization, where a component uses an incomplete or inappropriate permission check, allowing actions on objects that should be protected by additional context-based rules (here, the conversation-level assignment and visibility constraints).

Potential impact

  • Unauthorized users may edit customer-authored threads in conversations they cannot otherwise view.
  • Customer messages could be altered, leading to miscommunication with end users.
  • Audit trails and historical records of conversations may become unreliable.
  • Sensitive or regulated customer content could be indirectly exposed or corrupted through modified replies or internal workflows.
  • Internal business processes relying on accurate customer correspondence can be disrupted.

General mitigation guidance

Effective mitigation focuses on aligning authorization checks across related entities and enforcing the principle of least privilege:

  • Ensure that any operation on a thread also verifies the parent conversation's access rules, including "assigned-only" or other fine-grained constraints.
  • Centralize authorization decisions so that thread-level actions delegate to conversation-level policies where appropriate, avoiding duplicated or divergent checks.
  • Adopt a secure-by-default pattern where the more restrictive policy is applied if multiple policies may govern an operation.
  • Clearly model ownership and assignment relationships in the authorization layer so that edit, view, and reply actions share consistent access conditions.
  • Regularly review permission models when introducing new resources or endpoints to avoid partial or incomplete checks.

How teams detect issues like this

Detection generally relies on policy review and authorization-focused testing:

  • Perform code review to locate endpoints or controllers that operate on child resources (e.g., threads, comments, messages) using weaker checks than their parent resources (e.g., conversations, tickets).
  • Use static analysis or custom linters to flag direct authorization checks on sub-resources that do not reference or derive from the parent object's policy.
  • Incorporate security tests that simulate users with partial access (mailbox access but no conversation visibility) and verify that they cannot read or modify data in restricted conversations.
  • Introduce automated policy enforcement tests in CI that verify all CRUD operations for a resource share a consistent authorization strategy.

Sources

SourceLink
github.comgithub.com/freescout-help-desk/freescout/commit/cdadaf621bb1e1d017315df20d743671f7eae7a9
github.comgithub.com/freescout-help-desk/freescout/releases/tag/1.8.215
github.comgithub.com/freescout-help-desk/freescout/security/advisories/GHSA-4h5p-7f5c-q7gj

Frequently asked

questions

Yes, but only by authenticated users of the FreeScout instance. It is not exploitable by unauthenticated external attackers, but any user with mailbox access and restricted conversation visibility may exploit it through the web interface or related APIs.

The attacker must have a valid FreeScout account with access to the mailbox that contains the affected conversations. They do not need to be assigned to the specific conversation, and they may lack permission to view that conversation through normal UI flows.

The safest pattern is to ensure thread edit checks are derived from or delegated to the conversation's authorization policy. Any action on a thread should first confirm the user's permission to access the parent conversation under the strictest applicable rules, such as "assigned-only" constraints.

Preventive strategies include centralizing authorization logic, avoiding duplicated policy implementations across related resources, and requiring that all child-resource operations confirm access to their parent objects. Regular security reviews, automated tests for access control, and consistent use of an authorization framework can help catch these discrepancies before release.

Find out what's already
exploitable in your codebase.