/

CVE-2026-41191

Severity:

HIGH RISK

(7.1)

Incorrect Authorization in FreeScout

CVE-2026-41191

Deferred

Vulnerability type

Category:

Incorrect Authorization

CWE:

CWE-863

Impact:

Privilege Escalation / Unauthorized Configuration Change

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

An incorrect authorization flaw in FreeScout allows users with limited mailbox permissions to modify a hidden mailbox-wide chat setting via crafted requests.

Under certain configurations, a user who should only be able to edit the mailbox signature can still change the chat_start_new setting by issuing a direct POST outside the normal UI flow.

Affected context

The vulnerability occurs in the mailbox settings update flow handled by MailboxesController::updateSave() in FreeScout.

It affects deployments where:

  • Users are granted granular mailbox permissions (e.g., only the sig permission),
  • The UI correctly hides non-authorized fields but the backend still processes them,
  • The chat_start_new mailbox-wide chat configuration is present but not intended to be editable by those users.

In this context, the trusted boundary is incorrectly enforced only at the presentation layer (UI) and not consistently at the server side.

Exploit preconditions

  • Attack surface: HTTP(S) interface used to manage mailbox settings.
  • Required access: Authenticated user with at least mailbox-level access and the sig permission to the target mailbox.
  • Trigger point: Submitting a crafted POST request to the mailbox update endpoint (updateSave) that includes the chat_start_new parameter.
  • Why exploitation is possible: The controller persists the chat_start_new field outside the allowed-field filter, so server-side authorization does not align with the more restrictive UI-level permission model. As a result, additional fields sent by the client are accepted and applied even when they are not exposed in the UI.

Why this happens

This issue stems from inconsistent authorization enforcement between the user interface and the backend controller logic.

While the UI respects permission boundaries and only shows the signature field to users with the sig permission, MailboxesController::updateSave() persists the chat_start_new field without subjecting it to the same allowed-field filtering and permission checks.

This maps to CWE-863: Incorrect Authorization, where the application fails to enforce appropriate authorization controls on a sensitive operation, allowing users to perform actions beyond their intended permissions through direct manipulation of request parameters.

Potential impact

  • Users with limited permissions could change mailbox-wide chat behavior (chat_start_new) for all users.
  • Unexpected activation or deactivation of chat features that may affect customer communication workflows.
  • Policy violations where non-admin staff quietly alter mailbox configuration contrary to organizational controls.
  • Increased operational risk if mailbox configuration is relied on to enforce communication or compliance requirements.

General mitigation guidance

Mitigation centers on enforcing server-side authorization and strict parameter handling for sensitive settings.

Recommended patterns include:

  • Applying a robust allowed-field filter on the backend that is derived from the user's effective permissions, not from client-side form structure.
  • Performing explicit authorization checks for each sensitive mailbox setting (such as chat configuration) before persisting changes.
  • Using centralized policy/permission checks so that UI behavior and backend enforcement share the same source of truth.
  • Treating all client-supplied fields as untrusted, ignoring or rejecting parameters that the current user is not authorized to modify.
  • Logging and auditing configuration changes to detect unauthorized or unexpected mailbox setting updates.

How teams detect issues like this

Detection typically involves both code-level and operational approaches:

  • Static analysis / code scanning:
  • Flag controller actions that accept and persist request data without mapping through an explicit whitelist tied to permissions.
  • Identify instances where authorization checks are only present in the UI layer but missing in server-side handlers.
  • Code review cues:
  • Look for update methods that call update() or similar persistence APIs directly on request input arrays.
  • Verify that every mailbox setting, especially global or impact-wide toggles (like chat settings), has associated capability checks.
  • Runtime / operational monitoring:
  • Monitor logs for configuration changes initiated by low-privilege roles.
  • Implement security or audit logging for mailbox setting changes and regularly review them for anomalies.
  • Automated testing:
  • Add authorization regression tests that attempt direct POST/PUT requests for hidden fields using low-privilege test accounts.

Sources

SourceLink
github.comgithub.com/freescout-help-desk/freescout/commit/fb130de64e1c830d85dd6988eaa08d725a7be954
github.comgithub.com/freescout-help-desk/freescout/releases/tag/1.8.215
github.comgithub.com/freescout-help-desk/freescout/security/advisories/GHSA-wpv9-c2gv-2j82

Frequently asked

questions

It is only exploitable by authenticated users with access to the relevant mailbox. There is no unauthenticated remote exploit; attackers must already have a valid account and some level of mailbox permission.

The attacker must have at least the mailbox sig permission (or similar limited mailbox access) to the target mailbox. With that, they can craft a direct POST request to the update endpoint and modify the chat_start_new setting even though it is not visible in the UI.

Ensure that all sensitive configuration fields are protected by server-side authorization checks and processed through an explicit, permission-aware whitelist of allowed fields. Backend logic should ignore or reject any parameters that the user is not authorized to modify, regardless of what the client sends.

Align UI and backend authorization by centralizing permission logic, enforce strict server-side validation for every state-changing action, and add automated tests that simulate direct API misuse (e.g., posting hidden fields). Combine this with code review practices that flag any update actions not guarded by explicit capability checks.

Find out what's already
exploitable in your codebase.