Skip to main content

RPly CVE-2026-115722

| EUVDEUVD-2026-108710 MEDIUM
Improper Validation of Array Index (CWE-129)
2026-10-23 VulnCheck GHSA-pqc7-7g6c-cw4g
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Deliver crafted PLY file to victim
  2. Exploit
    Victim application parses file with RPly
  3. Execution
    Malformed list type dereferences out-of-bounds handler
  4. Impact
    Crash or memory corruption (DoS)

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Array index validation
Exploitation Conditions

Exploitation requires that an application using RPly (≤1.1.4) parse an attacker-controlled PLY file; the crafted file must declare a list property that specifies 'list' itself as the list's length type or value type, which causes ply_read_header_property() to accept it and ply_read_list_property() to call an out-of-bounds handler. The key LIMITING factors: delivery is local and requires victim-side processing of the malicious file (AV:L, UI:P) - there is no remote network trigger - so exploitation depends on getting the victim or a service to ingest the crafted PLY. The ASCII parsing path yields a crash (denial of service); the memory-corruption outcome is specific to the binary parsing path. No authentication is required of the attacker (PR:N), but the attacker does not act directly against a service - they supply input.

Impact

This is a genuine but moderate-priority issue rather than an urgent emergency. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, score 6.9 Medium) frames it as a locally-delivered, low-complexity flaw requiring passive user interaction - i.e. a victim application or user must process an attacker-supplied PLY file. There is no CISA KEV listing and no EPSS score in the supplied data, so there is no evidence of active or widespread exploitation; the signals point to a parser bug triggered by malicious input rather than a remotely automatable mass-exploitation target. The vuln.today decision label is 'this_month' (not act_now/emergency), which is consistent with the Medium severity and absence of KEV. Impact is primarily availability (VA:H - crashes) with limited integrity impact (VI:L - memory corruption in the binary path) and no confidentiality impact (VC:N). The description notes memory corruption in binary parsing, which could in principle be more serious than a crash, but the supplied evidence does not confirm code execution, so this should not be assumed. Reported by VulnCheck with a dedicated advisory and a technical write-up, indicating credible sourcing. EPSS and KEV are MISSING from the input - their absence is not itself a risk signal but limits confidence in estimating real-world exploitation likelihood.

Exploit ScenarioDerived

An attacker crafts a malicious PLY 3D-model file whose header declares a list property using 'list' as its length or value type. When a victim application built on RPly parses this file, ply_read_list_property() indexes an out-of-bounds handler, crashing the ASCII parser or corrupting memory in the binary parser. A public PoC reference exists (VulnCheck advisory and a hackmd write-up); it is not verified as working exploit code.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 23, 2026

Parsing an attacker-supplied PLY file with RPly 1.1.4 or earlier can crash a host application on the ASCII parsing path and corrupt memory on the binary parsing path, because the library accepts the token 'list' as the length type or value type of a list property and then indexes handler tables out of bounds. The weakness sits in ply_read_header_property() and is reached through ply_read_list_property(); an application is only exposed if it ingests a crafted PLY, so delivery is local and requires victim-side file processing (CVSS 3.1 AV:L/UI:R, no attacker authentication), not a remote network trigger. No confirmed in-the-wild exploitation or public exploit code was identified at time of analysis, though a public technical writeup of the property list type confusion exists; independent assessment rates this a genuine but moderate-priority issue to be handled within the current monthly patch cycle rather than an emergency.

RemediationAI

No vendor-released patch or fixed version was identified at time of analysis; versions through 1.1.4 remain affected, so track https://github.com/diegonehab/rply/issues/10 and the VulnCheck advisory for a released fix and upgrade RPly as soon as a version beyond 1.1.4 is published. Because the flaw is in header type resolution, the most direct compensating control is to pre-screen PLY headers before handing them to RPly and reject any element property whose list count type or item type is literally 'list'; this prevents ply_read_list_property() from being reached with an invalid handler index, at the cost of maintaining a parser-side validator, which must be kept in sync with the format specification. Additionally, restrict ingestion of untrusted PLY files to low-privilege, sandboxed worker processes with memory limits so a crash or memory corruption cannot take down the primary service - accepting the trade-off of added process overhead and restricted filesystem access for the parser. Where the binary PLY path is not required, forcing ASCII-only parsing limits the described outcome to a denial-of-service crash instead of memory corruption, but sacrifices binary PLY compatibility and performance, and does not remove the underlying parsing bug.

Affected VersionsENISA

rply 0 ≤1.1.4

Affected Packages

euvd rply no fix

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

PLY (Polygon File Format) is a lightweight mesh/point-cloud format whose header declares elements and, for each element, properties that may be scalars or lists. A list property is declared with a count type and an item type; RPly resolves each type name to an entry in an internal handler/index table during header parsing in ply_read_header_property(), then dispatches through that table in ply_read_list_property() (see rply.c lines 821-848 and 1228-1251 in the upstream repository). The root cause class is CWE-129, Improper Validation of Array Index: the parser does not reject the reserved token 'list' where a scalar type name is expected, so a header that names 'list' as the list's count type or item type produces an out-of-range handler index that is later dereferenced. The resulting behaviour differs by parsing mode - the ASCII reader crashes, while the binary reader can corrupt memory - meaning the achievable impact depends on which RPly entry point the embedding application uses. The trigger requires a crafted file only; no server-side interaction or credentials are involved, but the attacker does not act directly against a service.

Know when Rply 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 (VulnCheck) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Flaw requires a victim to parse an attacker-supplied local file (AV:L, UI:R), needs no privileges (PR:N), low-complexity trigger (AC:L); impact is mainly a crash (A:H) with limited memory-corruption integrity impact (I:L) and no confidentiality loss (C:N).

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

DescriptionCVE.org

RPly through 1.1.4 contains an improper array index validation vulnerability in ply_read_header_property() that accepts list as a list property's length or value type. Attackers can supply a crafted PLY file that makes ply_read_list_property() call an out-of-bounds handler, crashing ASCII parsing or corrupting memory in binary parsing.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Low
niche open-source PLY-parsing C library, limited enterprise deployment footprint
Data Quality
4 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

34
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +34
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.

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