CVE-2026-108748

Executive Summary

CVE-2026-108748 is a missing release of memory (CWE-401) vulnerability in Quarkus LangChain4j versions 1.9.0 through 1.14.1, exposed through the chat-scopes WebSocket endpoint /_chat/routes. Unauthenticated remote clients can repeatedly send CONNECT frames while reusing a single chatId, causing orphaned scope objects to accumulate in an internal activeScopes structure that is never released until the JVM exits. The result is progressive server memory exhaustion and degradation of availability, which is reflected in the CVSS 3.1 base score of 5.3 (AV:N/AC:L/PR:N/UI:N, with impact confined to Availability:Low).

Technical Analysis

The vulnerability resides in the chat-scopes management component of Quarkus LangChain4j. WebSocket clients interact with the endpoint at the path /_chat/routes, and the server tracks per-chat lifetime state in a collection referred to in the description as activeScopes. Under normal operation, a chat lifecycle should map a unique chatId to a single managed scope, and that scope is expected to be released when the corresponding chat session is torn down (for example, on disconnect or connection replacement).

The flaw is that CONNECT frames can be sent repeatedly while reusing one chatId. Each such CONNECT appears to cause a new scope object to be created and registered in activeScopes, but the prior scope for the same chatId is not released. The superseded scope becomes orphaned: no new client connection references it, but the reference held by activeScopes keeps the object reachable, preventing garbage collection. Because the map or collection entry is keyed/associated by chatId, repeatedly connecting with the same identifier concentrates orphaned objects in the same logical slot without ever pruning the stale entry.

Two properties make this exploitable at scale:

1. No authentication requirement. The endpoint accepts CONNECT frames from unauthenticated remote clients, so no credential or session is needed to drive allocation.
2. Unbounded accumulation. Orphaned scopes persist until the JVM exits, meaning memory is reclaimed only by a process restart. There is no natural timeout, eviction, or cleanup path described for these orphaned entries.

This is a resource-exhaustion condition rather than a memory-corruption bug. The attack does not require malformed frames, buffer overflows, or code execution primitives; it abuses correct-looking protocol traffic (valid CONNECT frames) to convert each request into a permanent heap allocation. This is squarely CWE-401 (Missing Release of Memory after Effective Lifetime), distinct from classic unbounded allocation (CWE-770) because the retained objects have already outlived their intended purpose and simply fail to be freed.

Exploitation Scenarios

No public proof-of-concept, Nuclei template, or exploit code is available for this CVE. The attack chain below is inferred strictly from the CWE-401 vulnerability class and the mechanics stated in the NVD description.

1. Reconnaissance / target identification. An attacker scans for internet- or intranet-exposed Quarkus applications that bundle LangChain4j chat-scopes functionality. Candidate hosts are those exposing the WebSocket endpoint at /_chat/routes. An attacker can confirm reachability with a standard WebSocket upgrade handshake to that path; no authentication is presented.

2. Triggering the flaw class. The attacker opens a WebSocket connection and transmits a CONNECT frame carrying a chosen chatId. On the initial CONNECT, the server registers a scope in activeScopes for that chatId. The attacker then sends additional CONNECT frames reusing the same chatId. Each reuse causes the server to allocate and register a new scope while the previous scope for that chatId is left orphaned in activeScopes. This is the missing-release condition (CWE-401): the reference is retained, so the memory is never reclaimed.

3. Payload / execution method (vulnerability-class level). The "payload" is not code but repeated, well-formed CONNECT frames. The attacker automates the loop — connect, send CONNECT with a fixed chatId, repeat — to amplify allocation. The attacker can parallelize across many connections and across many distinct chatId values to widen the allocation footprint. Because each reused CONNECT produces an additional orphaned scope, the growth is proportional to the number of frames sent, not to the number of distinct sessions.

4. Post-exploitation impact. As orphaned scopes accumulate, heap pressure increases. The JVM performs more frequent and longer garbage collections, latency rises, and available heap shrinks. Sustained pressure can lead to excessive GC pauses or an OutOfMemoryError, causing the chat-scopes subsystem — and potentially the host application if the heap is shared — to become unresponsive or crash. Recovery requires a process/JVM restart, which provides a trivial repeat-trigger if the endpoint remains exposed. The impact is availability degradation (CVSS Availability:Low per the official vector), with no stated impact to confidentiality or integrity.

Impact Assessment

The CVSS 3.1 base score is 5.3 (Medium) with vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L. Subscore interpretation:

• AV:N (Network) — the endpoint is reachable over the network; exploitation does not require local access.
• AC:L (Low) — no special conditions or race windows are required; the attack relies on documented, repeatable protocol interactions.
• PR:N (None) — CVE states unauthenticated remote clients can trigger the condition; no privileges are needed.
• UI:N (None) — the attacker does not depend on a victim's interaction.
• S:U (Unchanged) — impact is scoped to the vulnerable component.
• C:N / I:N — no confidentiality or integrity impact.
• A:L (Low) — availability is degraded, consistent with memory pressure rather than guaranteed total loss of service.

Affected systems are Quarkus applications using LangChain4j versions 1.9.0 through 1.14.1 that expose the chat-scopes WebSocket endpoint /_chat/routes. Blast radius depends on deployment topology: if the chat-scopes service shares a JVM/heap with other application functions, memory pressure can affect those co-resident functions too. In containerized or Kubernetes deployments with memory limits, sustained exhaustion can trigger OOMKills and pod restarts, creating a self-amplifying outage if traffic persists. CISA KEV status is NO, there is no confirmed in-the-wild exploitation evidence in the provided data, and EPSS has not been scored by FIRST.org. Because the attack is unauthenticated, low-complexity, and repeatable, exposure of the endpoint to untrusted networks should be treated as a meaningful availability risk despite the Medium severity.

Detection Guidance

Sigma Rule

title: Quarkus LangChain4j Chat-Scopes Memory Exhaustion via Repeated CONNECT Frames
id: 7c2f4a91-1d6b-4e3a-9f58-0a1b2c3d4e5f
status: experimental
description: Detects repeated WebSocket CONNECT frames to the Quarkus LangChain4j chat-scopes endpoint /_chat/routes reusing one chatId, indicative of CWE-401 memory exhaustion (CVE-2026-108748).
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-108748
author: valtersit.com
date: 2026/01/01
tags:
  - attack.t1499
  - cve.2026-108748
logsource:
  category: websocket
  product: quarkus
detection:
  selection_endpoint:
    uri_path|contains: '/_chat/routes'
  selection_action:
    ws_frame_type: 'CONNECT'
  timeframe: 1m
  condition: selection_endpoint and selection_action | count() by src_ip, chatId > 25
fields:
  - src_ip
  - chatId
  - uri_path
falsepositives:
  - Legitimate clients reconnecting rapidly due to flaky networks
  - Load testing or health-check harnesses reusing fixed chatId values
level: medium

YARA Rule

rule CVE_2026_108748_Quarkus_LangChain4j_Scope_Exhaustion
{
    meta:
        description = "Detects payloads or scripts interacting with the Quarkus LangChain4j chat-scopes endpoint reusing a single chatId across repeated CONNECT frames (CVE-2026-108748)"
        author = "valtersit.com"
        date = "2026-01-01"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-108748"
        cve = "CVE-2026-108748"

    strings:
        $endpoint = "/_chat/routes" ascii wide nocase
        $connect  = "CONNECT" ascii wide
        $chatid   = "chatId" ascii wide nocase

    condition:
        any of them
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-108748 Quarkus LangChain4j chat-scopes CONNECT frame reuse possible memory exhaustion"; flow:established,to_server; http.uri; content:"/_chat/routes"; http.header_names; content:"Upgrade"; nocase; http.header; content:"websocket"; nocase; threshold:type both, track by_src, count 50, seconds 60; classtype:attempted-dos; reference:cve,2026-108748; metadata:created_at 2026_01_01, updated_at 2026_01_01; sid:2026108748; rev:1;)

Elastic Detection

sequence by source.ip with maxspan=60s
  [ network where network.protocol == "websocket" and url.path == "/_chat/routes" ]
  [ network where network.protocol == "websocket" and url.path == "/_chat/routes" ]
  [ network where network.protocol == "websocket" and url.path == "/_chat/routes" ]

Splunk SPL Query

index=network (url_path="/_chat/routes" OR uri_path="/_chat/routes")
| eval chatid=coalesce(chatId, chat_id, ws_chat_id)
| stats count AS connect_count dc(chatid) AS distinct_chats values(chatid) AS chatids BY src_ip
| where connect_count > 50 AND distinct_chats < 3
| sort - connect_count
| table src_ip connect_count distinct_chats chatids

Wazuh OSSEC Rule

<group name="quarkus,langchain4j,web,_chat_routes,">
  <rule id="108748" level="10">
    <decoded_as>json</decoded_as>
    <field name="url_path">/_chat/routes</field>
    <field name="ws_frame_type">CONNECT</field>
    <description>CVE-2026-108748: Repeated CONNECT frames to Quarkus LangChain4j chat-scopes endpoint /_chat/routes with reused chatId - possible memory exhaustion</description>
    <mitre>
      <id>T1499</id>
    </mitre>
    <group>dos,attack,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). No vendor fix, workaround, or affected-version mapping is available from tracked sources; the version range 1.9.0–1.14.1 is taken from the CVE description. The mitigations below are operational and architectural controls, not a vendor patch.

1) Immediate mitigations

• Restrict network access to the chat-scopes WebSocket endpoint /_chat/routes. Place it behind authentication and/or an authenticated reverse proxy or API gateway, since the described attack requires only unauthenticated access. Deny public exposure wherever possible.
• Enforce per-source connection and CONNECT-frame rate limits at the edge (reverse proxy / load balancer / WAF). Throttle repeated CONNECT frames, especially those reusing the same chatId.
• Reject or de-duplicate CONNECT frames that reuse an chatId already associated with an active connection, if the application layer can be configured to do so.
• Set conservative JVM heap limits and container memory limits, and configure aggressive restart/health-probe behavior so orphaned-scope accumulation triggers prompt recovery rather than gradual degradation. Note this is containment, not a fix — the underlying leak persists until JVM exit.

2) Patch / upgrade steps

• No official patched version is identified in the provided data. Monitor the Quarkus and LangChain4j project advisories for a release that addresses CWE-401 in chat-scopes (watch the Quarkus security advisories page and the LangChain4j GitHub releases).
• Until a fix is published, inventory all deployments using Quarkus LangChain4j 1.9.0–1.14.1. Where the chat-scopes feature is unused, disable it or remove the dependency to eliminate the attack surface. Where it is required, apply the network and rate-limiting controls above.

3) Long-term hardening

• Track upstream Quarkus/LangChain4j security advisories and adopt a patch-management cadence that includes framework-level dependencies.
• Add memory-pressure and GC telemetry with alerting so orphaned-object growth is detected before availability impact.
• Adopt secure-by-default deployment patterns: do not expose framework management/chat endpoints to untrusted networks; require authentication on all WebSocket endpoints.
• Include CWE-401 leak testing in application lifecycle and load-testing suites, particularly for connection-oriented endpoints.

References

• NVD — CVE-2026-108748: https://nvd.nist.gov/vuln/detail/CVE-2026-108748
• CWE-401 — Missing Release of Memory after Effective Lifetime: https://cwe.mitre.org/data/definitions/401.html
• MITRE ATT&CK T1499 — Endpoint Denial of Service: https://attack.mitre.org/techniques/T1499/
• FIRST.org EPSS — CVE-2026-108748 (not yet scored): https://api.first.org/data/v1/epss?cve=CVE-2026-108748
• CISA Known Exploited Vulnerabilities Catalog (CVE-2026-108748 not listed as of publication): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

No public proof-of-concept, exploit code, or Nuclei template is available for this CVE. No threat actor campaigns or exploit-in-the-wild evidence were identified in the provided data, and the CVE is not listed in CISA KEV.