Skip to main content

lud jsv CVE-2026-117680

| EUVDEUVD-2026-114847 LOW
Improper Check for Unusual or Exceptional Conditions (CWE-754)
2026-11-01 EEF
2.1
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Access
    Reach jsv-validated endpoint using a backtracking-prone schema
  2. Delivery
    Submit padded string forcing catastrophic regex backtracking
  3. Exploit
    Budget exhaustion returns :nomatch like a real non-match
  4. Execution
    patternProperties subschema skipped or not deny-list inverted
  5. Impact
    Invalid/denied data accepted and processed downstream

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A10:2025 - Mishandling of Exceptional Conditions
ASVS 5.0
V16 - Security Logging and Error Handling Unusual condition handling
Exploitation Conditions

Exploitation requires the application's jsv schema (jsv 0.1.0 before 0.26.2) to contain a pattern or patternProperties regex that PCRE can only match after exploring a catastrophic branch first - specifically nested quantifiers or overlapping alternatives such as ^(?:(a+)+b|a+!)$; linear patterns never exhaust the 10_000 + 50 * byte_size budget and are unaffected. The bypass is security-relevant only where that regex gates untrusted input via not, anyOf, oneOf, if, contains, or patternProperties (worst case when patternProperties is not paired with additionalProperties: false). No authentication is required (PR:N) and the attacker controls the validated data but not the schema; the key limiting factor is that a vulnerable schema definition must already be present, so default or linear-regex schemas are not exposed.

Impact

Low, conditional risk. The input assigns CVSS 2.1 and a vuln.today decision label of 'monitor', with no EPSS score supplied and no CISA KEV listing, so there is no signal of active exploitation - a detailed proof-of-concept is described in the GHSA advisory but it is a documented reproduction, not verified packaged exploit code. The signals are largely consistent in pointing to a low-priority issue, but there is one notable conflict: the supplied CVSS 4.0 vector uses AV:L (local), whereas the description explicitly calls this an 'unauthenticated remote attacker' who 'controls the data' - the attack vector is better characterized as network (AV:N), so the provided vector likely understates reach while the AT:P (attack requirement present) correctly captures that a specially-shaped schema must already exist. PR:N confirms no authentication is needed. Real-world impact is a schema-validation bypass with limited integrity effect (VI:L; confidentiality and availability unaffected), and it only bites applications that both use jsv and define a security-relevant deny-list via not/pattern or patternProperties over a regex with catastrophic backtracking - the attacker cannot supply the schema. This is a genuine but narrow correctness/validation-bypass bug, not a high-urgency emergency; patch when convenient as the vendor fix is available.

Exploit ScenarioDerived

An application validates untrusted JSON with jsv using a schema whose patternProperties or not regex contains nested quantifiers or overlapping alternatives (e.g. ^(?:(a+)+b|a+!)$). A remote unauthenticated attacker pads an input string (about twenty repeated characters) so PCRE exhausts the backtracking budget on the catastrophic branch before reaching the branch that would match; :re.run/3 returns :nomatch, the engine treats the matching value as a non-match, and the subschema is skipped or the not deny-list is bypassed, so data the schema should reject is accepted. A working PoC is documented in the GHSA advisory but is not verified as packaged exploit code.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Nov 01, 2026

Schema validation bypass in the lud jsv JSON Schema validator (versions 0.1.0 through 0.26.1) lets an unauthenticated remote attacker slip input past pattern, patternProperties, propertyNames and not constraints. The root cause is that jsv's backtracking-limited regex helper runs :re.run/3 without :report_errors, so a PCRE match_limit exhaustion is returned as :nomatch and treated as a genuine non-match - a failed pattern under not, anyOf, oneOf, if or contains can therefore make the parent schema succeed, and a skipped patternProperties subschema leaves the value checked against additionalProperties or not at all. Exploitation is conditional: the deployed schema must already contain a regex with nested quantifiers or overlapping alternatives that forces backtracking before the matching branch, which is why the assessed vector is network-reachable but high-complexity with only low integrity impact (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/C:N/I:L/A:N; vendor CVSS 4.0 base 2.1); the vendor advisory publishes a proof-of-concept walkthrough, but it is not verified as working exploit code and there is no evidence of active exploitation (not in CISA KEV), with the overall priority rated monitor.

RemediationAI

Vendor-released patch: upgrade jsv to 0.26.2 (https://hex.pm/packages/jsv/0.26.2), which treats an exhausted backtracking budget as indeterminate instead of a non-match, halts validation and returns a JSV.ValidationError of kind indeterminate_pattern that not, anyOf, oneOf, if and contains cannot invert; the fix is tracked in commit defdb8a68ac7f218aa5dfe85190d484017cb8817 and documented in the advisory https://github.com/lud/jsv/security/advisories/GHSA-cvmg-hgv6-jqcp. Note the behavioural consequence of the patch: data that matches a pattern but requires heavy backtracking to be recognised is now always rejected, so rewrite affected patterns without nested quantifiers or overlapping alternatives to restore normal behaviour. If upgrading is not immediately possible, the vendor lists two workarounds - pair every patternProperties with additionalProperties: false, so that a key whose match exhausts the budget is rejected rather than accepted unchecked (trade-off: valid keys needing heavy backtracking are also rejected), and avoid expressing deny-lists as a not subschema with a pattern evaluated against untrusted input, rewriting schema regexes to avoid nested quantifiers and overlapping alternatives. No patch-version-independent mitigation removes the condition for schemas that genuinely depend on such patterns; validating untrusted input with linear-only regexes is the safer configuration.

Affected VersionsENISA

jsv 302a5d0803468f81a1cf08e3b67d8b14cee759ca <defdb8a68ac7f218aa5dfe85190d484017cb8817
jsv 0.1.0 <0.26.2

Affected Packages

euvd jsv fix: 0.26.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

jsv is an Elixir JSON Schema validator covering draft 7 and 2020-12. Its JSV.Helpers.RegexExt.bounded_match?/2 (lib/jsv/helpers/regex_ext.ex) evaluates schema regexes through Erlang's :re.run/3 (PCRE) with match_limit and match_limit_recursion set to 10_000 + 50 * byte_size(subject), capped at 10,000,000. The call omits :report_errors, so PCRE's match_limit error is indistinguishable from a legitimate :nomatch; the helper compares the result to :match and returns false for both a real non-match and an exhausted budget. That boolean feeds JSV.Vocabulary.V202012.Validation.validate_keyword/3 for the pattern keyword (including under propertyNames) and JSV.Vocabulary.V202012.Applicator for deciding which patternProperties subschemas apply, with the draft 7 vocabulary delegating to the same modules. The flaw class is CWE-754 (Improper Check for Unusual or Exceptional Conditions): an indeterminate error condition is collapsed into a valid negative result. Inversion happens through JSON Schema combinators - under not, anyOf, oneOf, if and contains a spuriously failing subschema can make the parent succeed, and under patternProperties a skipped subschema means the value is validated against additionalProperties or nothing. Before the budget was introduced the same keywords used Regex.match?/2, which fails identically at Erlang's default 10,000,000-step limit; the budget merely lowered the padding needed (from 25 to 20 repeated characters in the advisory's example pattern). The adversary controls the validated data, not the schema, and linear patterns never exhaust the budget, so exposure is confined to schemas whose regex explores a catastrophic branch before the branch that matches.

Know when Jsv 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 (EEF) PRIMARY 2.1 LOW
CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
vuln.today AI 3.7 LOW

Remote unauthenticated attacker-controlled data (AV:N/PR:N/UI:N) but requires a pre-existing catastrophic-backtracking schema (AC:H); yields a limited validation bypass (I:L) with no confidentiality or availability impact.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Improper Check for Unusual or Exceptional Conditions vulnerability in the pattern and patternProperties keywords in lud jsv allows an unauthenticated remote attacker to bypass schema validation via a string that matches a schema regex only after heavy backtracking. JSV.Helpers.RegexExt.bounded_match?/2 runs schema regexes with a backtracking budget but calls :re.run/3 without :report_errors, so a match that exhausts the budget returns the same :nomatch as a real non-match. A key that matches a patternProperties regex is then checked against additionalProperties or not at all, and a string that matches a not subschema with a pattern is accepted. Before the budget existed, Regex.match?/2 failed the same way at Erlang's default match limit.

Only schemas whose regex explores a catastrophic branch before the branch that matches are affected. The attacker controls the data, not the schema, and linear patterns never exhaust the budget.

This issue affects jsv: from 0.1.0 before 0.26.2.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Low
niche Elixir/Erlang JSON-schema validation library, limited ecosystem footprint
Data Quality
6 sources
Confidence: High

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 LOW
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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· derived
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

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

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

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