Skip to main content

JLine EUVDEUVD-2026-85531

| CVE-2026-77423 HIGH
Inefficient Regular Expression Complexity (ReDoS) (CWE-1333)
2026-09-23 GitHub_M
7.5
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Access interactive less session over SSH/Telnet
  2. Delivery
    Enter nested-quantifier search/filter pattern
  3. Exploit
    Regex applied to non-matching file content
  4. Execution
    Catastrophic backtracking blocks session thread
  5. Persist
    Repeat to exhaust worker pool
  6. Impact
    Denial of service

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V2 - Validation and Business Logic Regex complexity limits
MITRE ATT&CK

1 technique across 1 tactic: Impact

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the application to embed JLine's built-in less viewer (Less.java) and to expose it interactively so the attacker can supply search or display-filter patterns - the primary risk profile is multi-user Telnet or SSH deployments backed by a bounded worker pool. The attacker must be able to type a search/display-filter pattern into an active less session, meaning interactive session access is needed (not purely anonymous remote access), and the file content being viewed must contain non-matching lines against which the backtracking regex runs. Limiting factors: impact is availability-only (session thread hang, worker-pool exhaustion) with no data compromise, and applications not exposing the less viewer to untrusted users are unaffected. Versions 3.30.15 and 4.3.1 remediate via SafeRegex and regex timeouts.

Impact

The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) rates this as a network, unauthenticated, availability-only denial of service, which is defensible for a Telnet/SSH-exposed service but treats the search-pattern input as attacker-controllable without any session foothold. In practice the malicious regex comes from whoever is driving the interactive less viewer, so realistic exploitation requires an established interactive session - I assess PR:L rather than PR:N, lowering the effective severity to roughly 6.5. No EPSS score, no CISA KEV listing, and no public proof-of-concept are present in the supplied intelligence, so there is no signal of active or automated exploitation - this is no public exploit identified at time of analysis. The impact is bounded to availability (C:N/I:N): a hung session thread and, in bounded worker-pool deployments, pool exhaustion affecting other users. Net: a legitimate but low-urgency ReDoS/DoS issue, materially lower real-world priority than the 7.5 headline suggests because it needs an interactive session and only degrades availability.

Exploit ScenarioDerived

An attacker with access to an interactive JLine-based console (e.g. a Telnet/SSH-exposed CLI application using the built-in less viewer) enters a nested-quantifier search or display-filter pattern such as (a+)+b. When applied to non-matching file lines, Java's backtracking regex engine consumes excessive CPU and indefinitely blocks the session thread; repeating this across sessions can exhaust a bounded worker pool and deny service to other users. No public exploit code is identified, though the nested-quantifier trigger is well understood and trivial to reproduce.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 23, 2026

Denial of service in JLine's built-in less viewer affects all 3.x releases from 3.0.0 before 3.30.15 and 4.x releases before 4.3.1: a user-supplied search or display-filter pattern containing nested quantifiers is handed straight to Java's backtracking regex engine and applied repeatedly across file content, so a pattern run against non-matching lines can consume excessive CPU and block the session thread indefinitely. The practical risk profile is multi-user Telnet or SSH deployments that embed the less viewer, where repeated sessions can exhaust a bounded worker pool and deny service to other users; the independent assessment scores this as availability-only (CVSS 3.1 A:H, no confidentiality or integrity impact) and notes that an interactive session foothold and viewable file content are prerequisites, which the published vector's PR:N rating does not reflect. No public exploit code and no confirmed active exploitation were identified at time of analysis, so exploitation is opportunistic rather than observed. The fix is the SafeRegex wrapper plus regex timeouts shipped in 3.30.15 and 4.3.1.

RemediationAI

Vendor-released patch: upgrade to JLine 3.30.15 or 4.3.1 (see https://github.com/jline/jline3/releases/tag/jline-3.30.15 and https://github.com/jline/jline3/releases/tag/4.3.1), which route the less viewer, history glob, Nano search, and grep pattern handling through org.jline.utils.SafeRegex with regex timeouts; the underlying changes are in PRs https://github.com/jline/jline3/pull/2012 and https://github.com/jline/jline3/pull/2018 and commits 1d5fc3099e77938b971e197211cad2d4fbb17541 and 341ee69ccc57b7733c1b40d6993219b64b3206ae. Where the upgrade cannot be applied immediately, treat the less viewer as untrusted-input surface: restrict interactive access to the Telnet/SSH service hosting it to authenticated, trusted operators (the trade-off is loss of multi-tenant access, and the underlying code remains vulnerable for any user who is allowed in), or disable or replace the built-in less/viewer command in your command registry so no user-supplied search or display-filter pattern reaches the backtracking engine (trade-off: loss of in-app paging, and grep/history-style features may still need review since the same pattern class was hardened upstream). Isolate the viewer from the shared worker pool - dedicate a small, separately bounded pool or per-session thread with a hard execution timeout so one hung session cannot starve other users (trade-off: added complexity and possible abrupt session termination) - and monitor session threads for sustained high CPU as a detection signal. There is no configuration flag in affected releases that bounds regex evaluation, so patching or removing the viewer path is the only complete mitigation.

Affected VersionsENISA

jline3 3.0.0, < 3.30.15
jline3 4.0.0, < 4.3.1

Affected Packages

euvd jline3_3_0_0 fix: 3.30.15
euvd jline3_4_0_0 fix: 4.3.1

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The root cause is CWE-1333 (Inefficient Regular Expression Complexity, i.e. ReDoS). JLine's built-in less implementation in builtins/src/main/java/org/jline/builtins/Less.java accepts user-controlled patterns through getPattern(boolean doDisplayPattern) - the values typed into a less session's search prompt ('/') or display-filter prompt ('&') - compiles them with java.util.regex.Pattern, and then applies the compiled pattern repeatedly to every line of the viewed file (matcher(line).find() in moveToNextMatch, moveToPreviousMatch, and prevLine2display). Java's regex engine is a backtracking engine with no built-in step budget, so a pattern such as one containing nested quantifiers whose match attempt branches exponentially can be evaluated against a single non-matching line for an unbounded time; because the viewer iterates over many lines this makes the cost effectively permanent for that session. In Telnet or SSH server deployments where each session is served by a worker from a bounded thread pool, several such sessions starve the pool and deny service to all other users. The vulnerability is confined to the builtins viewer code path and does not affect JLine's terminal emulation or line-reader core. The upstream fix introduces org.jline.utils.SafeRegex, a bounded/guarded compile-and-match wrapper backed by RegexTimeoutException, and the corresponding pull requests (jline/jline3#2012 and #2018, commits 1d5fc3099e77938b971e197211cad2d4fbb17541 and 341ee69ccc57b7733c1b40d6993219b64b3206ae) also harden the same pattern hazard in sibling builtins - Commands.java history glob matching, Nano search, and PosixCommands grep - showing the unsafe pattern handling was broader than the less viewer alone. The affected CPE is cpe:2.3:a:jline:jline3:*:*:*:*:*:*:*:*, i.e. every jline3 version line has an affected build.

Know when Jline gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (GitHub_M) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 6.5 MEDIUM

Attacker-controlled search pattern originates from an interactive less session, so PR:L not PR:N; low complexity, availability-only impact (thread/pool exhaustion), no C/I.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE HIGH
Red Hat 7.5 HIGH

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

2
Patch available
Sep 23, 2026 - 20:03 EUVD
CVE Published
Sep 23, 2026 - 18:17 cve.org
HIGH 7.5

DescriptionCVE.org

JLine is a Java library for handling console input. From 3.0.0 until 3.30.15 and 4.3.1, the JLine built-in less viewer passes user-controlled search and display-filter patterns from getPattern(boolean doDisplayPattern) in builtins/src/main/java/org/jline/builtins/Less.java directly to Java's backtracking regular expression engine and repeatedly applies them to file content. A nested-quantifier expression evaluated against non-matching lines can consume excessive CPU and indefinitely block the session thread, and repeated sessions in Telnet or SSH deployments can exhaust a bounded worker pool. This issue is fixed in versions 3.30.15 and 4.3.1.

Technical POC Analysis

CWE-1333, inefficient regular expression complexity, in the JLine built-in less pager.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

JLine's built-in less viewer is affected by a denial-of-service vulnerability across all 3.x releases prior to 3.30.15 and 4.x releases prior to 4.3.1, where a crafted search pattern can exhaust CPU and block user sessions. This creates a high risk for multi-user Telnet or SSH deployments that embed the viewer, as repeated exploitation can degrade or deny service to other users. No vendor-released patch identified at time of analysis, and no public exploit identified at time of analysis, but the prerequisite interactive session foothold and viewable file content mean exposed environments should act promptly.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations include restricting access to the less viewer to trusted users, disabling it in multi-user Telnet/SSH deployments if not essential, implementing CPU time limits or thread timeouts on worker pools, monitoring for abnormal CPU consumption, and applying rate limiting to sessions. Once JLine 3.30.15 or 4.3.1 becomes available, testing and deploying them would address the vulnerability.

Threat Intelligence Overview

EPSS Score
0.4%
Top 70% exploitable
Prevalence
Medium
JLine3 is a widely-used Java CLI library, but the vulnerable less viewer in multi-user deployments is narrower
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Server 16.0 Affected
SUSE Linux Enterprise Server 16.1 Affected
SUSE Linux Enterprise Server for SAP applications 16.0 Affected
SUSE Linux Enterprise Server for SAP applications 16.1 Affected
openSUSE Leap 16.0 Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy