/

CVE-2026-44633

Severity:

HIGH RISK

(8.1)

Missing Authorization in Live Helper Chat 4.84v

CVE-2026-44633

Deferred

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-863

Impact:

Unauthorized Access, Data Tampering, and Potential Operator-Side Script Injection

Severity:

HIGH RISK

(8.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 authorization flaw in the Live Helper Chat REST API allows a user with the lhchat/use permission to update chat records in departments they are not allowed to read.

Because the endpoint accepts arbitrary chat object fields, an attacker can alter chat hashes, statuses, and admin operation fields, enabling unauthorized access or tampering via visitor/widget paths and potentially injecting JavaScript into operator-side views.

Affected context

This issue affects Live Helper Chat deployments that expose the REST API and delegate chat-related actions using the lhchat/use permission.

The vulnerable behavior occurs on the chat update endpoint, where authorization is checked only for the generic ability to use chat functions and not for per-chat or per-department access.

In such setups, users who cannot legitimately read certain department chats may still update those chats and influence how they are later accessed or rendered.

Exploit preconditions

  • Attack surface: Live Helper Chat REST API chat update endpoint.
  • Required access: A valid REST user/account with the lhchat/use permission and access to the API endpoint.
  • Required knowledge: Ability to identify or guess chat identifiers belonging to other departments (e.g., via API responses, logs, or predictable IDs).
  • Trigger point: Sending crafted update requests that modify arbitrary fields of chat objects, including hash, status, and operation_admin.
  • Why exploitation is possible: The endpoint authorizes based on a broad capability (lhchat/use) without enforcing fine-grained checks that the caller is allowed to read or modify the specific chat or department. Arbitrary field updates allow attackers to change routing and presentation of chats.

Why this happens

The root cause is a missing authorization check on a sensitive update operation, aligning with CWE-863: Incorrect Authorization.

The chat update endpoint accepts arbitrary chat fields and only verifies that the caller has a general "use chat" permission, rather than confirming that the caller can read or manage the specific chat instance or its department.

This coarse-grained authorization, combined with an over-permissive update payload, lets untrusted users alter security-relevant fields (such as hash, status, and operation_admin) that later control access paths and UI behavior, including server-side emission of JavaScript toward operators.

Potential impact

  • Unauthorized modification of chat metadata across departments.
  • Bypassing department visibility rules to access chats that should be unreadable to the attacker.
  • Tampering with chat status to close, reopen, or re-route conversations improperly.
  • Altering chat hashes to gain access via visitor or widget paths that rely on those values.
  • Injecting crafted values into operation_admin that may later be emitted as operator-side JavaScript, potentially enabling script execution in operator browsers.

General mitigation guidance

Effective mitigation focuses on tightening authorization and constraining which fields can be updated:

  • Enforce per-chat and per-department authorization checks on the update endpoint to ensure callers can only modify chats they are permitted to read or manage.
  • Introduce field-level access control, allowing only a minimal, vetted subset of chat attributes to be modified by REST clients, and treating security-sensitive fields (e.g., identifiers, hashes, status, code-like fields) as server-controlled.
  • Normalize and sanitize any data that may be rendered into JavaScript or HTML for operators, using contextual encoding and avoiding direct emission of user-controlled values into script contexts.
  • Apply principle of least privilege to API roles: split generic usage rights from administrative or cross-department capabilities and avoid granting broad permissions to routine integration accounts.
  • Design REST endpoints with intent-based payloads (e.g., dedicated actions like "close chat" or "assign department") rather than exposing raw object updates, limiting the attack surface of state changes.

How teams detect issues like this

Detection can rely on both code-centric and operational approaches:

  • Use static analysis or code review to identify endpoints that:
  • Accept arbitrary object field updates (e.g., mapping request bodies directly onto models).
  • Gate access solely on broad permissions without checking ownership, department, or explicit resource-level rights.
  • During manual review, flag APIs where user-controlled fields influence:
  • Access paths (hashes, tokens).
  • Status or routing decisions (department, operator assignment).
  • Content rendered into templates or JavaScript.
  • Enable detailed logging of REST API calls, including actor identity, target chat ID/department, and modified fields, then monitor for:
  • Cross-department updates by the same account.
  • Frequent or unusual changes to hashes, statuses, or operation_admin values.
  • Incorporate policy checks in CI/CD or automated security testing to enforce rules such as "update handlers must validate resource ownership" and "user input cannot be emitted directly into script contexts."

Sources

SourceLink
github.comgithub.com/LiveHelperChat/livehelperchat/security/advisories/GHSA-hjqq-qmvj-9whm

Frequently asked

questions

Yes. Any remote client that can authenticate to the REST API and obtain the lhchat/use permission can attempt to exploit the issue, assuming they can target chat IDs from other departments.

The attacker must have a valid Live Helper Chat account or REST credential with the lhchat/use capability and network access to the REST API endpoint. No direct access to restricted departments is required, as the flaw arises from missing per-chat/per-department checks.

Implement strict, resource-level authorization on every state-changing endpoint, ensuring that the caller is explicitly allowed to access and modify the specific resource. Combine this with field-level controls that restrict which properties clients can change and keep security-critical fields server-owned.

Adopt a consistent access-control model where APIs are designed around explicit permissions and resource ownership, avoid generic "update object" endpoints, and perform security reviews focused on cross-tenant and cross-department boundaries. Additionally, treat any data that may reach UI or script contexts as untrusted and enforce robust encoding and validation before rendering.

Find out what's already
exploitable in your codebase.