/

CVE-2026-40589

Severity:

HIGH RISK

(7.6)

Improper Authorization in FreeScout Customer Email

CVE-2026-40589

Deferred

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-639

Impact:

Information Disclosure and Cross-Account Data Rebinding

Severity:

HIGH RISK

(7.6)

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

FreeScout contained an authorization flaw that allowed a low-privileged agent to attach an email address already associated with a hidden customer in another mailbox to a visible customer they could edit.

When triggered, the server exposed the hidden customer's name and profile URL, and reassigned the email and related conversations, effectively leaking cross-mailbox data and breaking customer isolation.

Affected context

This vulnerability appears in FreeScout deployments where:

  • Multiple mailboxes are configured with separate, potentially restricted customer sets
  • Some customers are hidden or otherwise not meant to be visible to certain agents
  • Agents with limited privileges can still edit customer profiles in at least one mailbox
  • The platform allows adding and managing email addresses on customer records across mailboxes

In such environments, the email identity becomes a cross-mailbox key, and the lack of proper ownership checks allows one mailbox's agent actions to affect another mailbox's hidden customer.

Exploit preconditions

  • Attack surface: Web application interface for managing customers and their email addresses.
  • Required access: Authenticated, low-privileged agent account with permission to edit at least one customer that is visible to them.
  • Trigger point: Editing a visible customer and adding an email address that is already associated with a hidden customer in another mailbox.
  • Why exploitation is possible: The application validates that the agent can edit the visible customer but does not consistently verify whether the agent is authorized to interact with or reassign an email identity that is already bound to a hidden customer in another mailbox. As a result, cross-context resources (customer records and conversations) can be rebound without proper authorization checks.

Why this happens

The issue stems from improper authorization logic around resource binding and reuse of email addresses as a shared identifier across mailboxes.

When an agent adds an email to a customer they can edit, the system:

  • Looks up existing ownership of that email address
  • Reassigns it from the hidden customer to the visible one
  • Rebinds existing conversations to the new customer
  • Returns success feedback that includes data from the previously hidden customer

This sequence assumes that control over the visible customer implies control over any associated email, even when that email belongs to a different mailbox with more restrictive visibility rules.

Conceptually, this maps to CWE-639: Insecure Direct Object Reference, where the application fails to enforce authorization constraints when a user indirectly references or claims a resource (the email identity and associated customer record) that resides outside their permitted scope.

Potential impact

  • An agent may learn the full name of a hidden customer in another mailbox.
  • An agent may obtain the profile URL or identifier of a hidden customer, aiding enumeration or targeted probing.
  • Existing conversations and history associated with the email could be rebound to a visible customer, exposing cross-mailbox correspondence.
  • Historical conversation context may become misleading or corrupted, since threads are reattached to the wrong customer.
  • Mailbox boundaries and data separation between teams or departments can be weakened, undermining multi-tenant or multi-mailbox privacy assumptions.

General mitigation guidance

Effective mitigation focuses on enforcing strict, context-aware authorization checks when binding shared identifiers like email addresses:

  • Treat email addresses as resources with ownership and scope; before reassigning, verify that the acting user is authorized in all affected mailboxes or contexts.
  • Enforce mailbox-based isolation such that operations in one mailbox cannot implicitly modify or claim records belonging to another mailbox without explicit privilege.
  • Introduce invariant checks that prevent automatic reassignment of identities and conversations across access boundaries; require administrative workflows for cross-mailbox merges.
  • Limit information returned in success messages and UI flashes; avoid including names, profile URLs, or unique identifiers for entities outside the caller's authorization scope.
  • Apply least privilege to agent roles, minimizing capabilities to modify global identifiers or move customers and conversations across organizational boundaries.

These patterns reduce the risk of similar cross-context authorization issues even as data models evolve.

How teams detect issues like this

Organizations can identify similar authorization weaknesses through:

  • Static analysis and code inspection:
  • Flagging code paths that:
  • Reassign ownership of shared identifiers (like emails) without explicit authorization checks for all involved objects.
  • Join or merge records across mailbox, tenant, or organizational boundaries based solely on a shared key.
  • Reviewing controller or service methods that both modify customer records and rebind conversations or threads.
  • Targeted security code review:
  • Examining routines that resolve a "current customer" or "owner" based on user-supplied identifiers and checking for missing role or mailbox-scope validations.
  • Looking for places where success or error messages embed details about customers or conversations that the requesting user might not be allowed to see.
  • Policy and test enforcement:
  • Writing automated tests that simulate low-privileged agents attempting to attach shared identifiers (emails, phone numbers) associated with customers in other mailboxes.
  • Integrating security-focused regression tests into CI to ensure future changes do not reintroduce cross-mailbox resource reassignment.
  • Automated tooling:
  • Using application security testing tools (SAST/DAST) configured to focus on IDOR patterns and cross-tenant data access based on user-controlled parameters.

Sources

SourceLink
github.comgithub.com/freescout-help-desk/freescout/commit/2e2fe37111d92ac665b9ad8806eac94a1a3e502c
github.comgithub.com/freescout-help-desk/freescout/releases/tag/1.8.214
github.comgithub.com/freescout-help-desk/freescout/security/advisories/GHSA-mv55-3mgv-fxwr

Frequently asked

questions

Exploitation is limited to authenticated agents who can edit customers in at least one mailbox, but within that constraint any such agent could potentially claim an email belonging to a hidden customer in another mailbox and trigger data leakage and conversation reassignment.

The attacker needs a valid agent account with low-level permissions that allow editing a visible customer record. No administrative privileges are required; the attack occurs via standard customer-edit functionality.

The most robust pattern is to enforce strict authorization checks whenever an operation affects resources that may span multiple mailboxes or tenants, ensuring that the acting user has rights in all affected contexts before reassigning identifiers or conversations. Additionally, constrain UI and messaging so that operations never reveal information about entities outside the user's authorized scope.

Design the data model and authorization layer with explicit notions of ownership and scope (e.g., mailbox or tenant), and always gate cross-scope operations through central access-control checks. Combine this with systematic security reviews for IDOR patterns, automated tests that simulate cross-tenant actions, and conservative exposure of identifiers and metadata in responses and logs.

Find out what's already
exploitable in your codebase.