Skip to main content

libLAS CVE-2026-112059

| EUVDEUVD-2026-103521 MEDIUM
Out-of-bounds Write (CWE-787)
2026-10-18 VulnCheck GHSA-jvqw-8644-7mg5
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 .las file to victim
  2. Delivery
    Victim runs libLAS tool (lasinfo/las2las)
  3. Exploit
    Schema size truncated to 16 bits undersizes heap buffer
  4. Execution
    Point reader writes attacker bytes out of bounds
  5. Impact
    Heap memory corruption and crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

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 victim to process an attacker-supplied .las file that contains a LASSchema variable length record whose declared schema exceeds 65535 bytes, using libLAS version 1.8.1 or earlier (or an application that links it) via tools such as lasinfo, las2las, or las2txt. Limiting factors: the attack is LOCAL (AV:L) with no network reachability, and it depends on required user interaction (UI:P) - the malicious file must actually be opened/parsed by a libLAS consumer; no authentication or special privileges are needed (PR:N), and no non-default configuration is required, but the victim must choose to process the untrusted file.

Impact

This is a moderate, not urgent, priority. The authoritative CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H) scores 6.9 and tells a consistent story: exploitation is LOCAL (the attacker does not reach the target over a network) and requires passive user interaction (UI:P) - a victim must open or process a malicious .las file with a libLAS-linked tool. No EPSS score was provided, there is NO CISA KEV listing, and no confirmed public exploit code was supplied in the references (a detailed technical writeup on hackmd exists, which lowers the research barrier, but that is a vulnerability analysis, not a packaged exploit). The impact is primarily availability (VA:H, i.e. memory corruption/crash) with only limited integrity impact (VI:L) and no confidentiality impact (VC:N); although CWE-787 out-of-bounds writes can sometimes escalate to code execution, the vector's VI:L/VC:N rating indicates the realistic outcome assessed here is a crash rather than reliable arbitrary code execution. Signals are internally consistent - there is no network-vs-local conflict - so the main risk driver is simply whether users process untrusted LiDAR files. Given a local-only vector, required user interaction, a retired niche library, and no evidence of active exploitation, this is a real but low-to-moderate operational risk rather than a drop-everything issue.

Exploit ScenarioDerived

An attacker crafts a malicious .las LiDAR file containing a LASSchema variable length record whose declared schema size exceeds 65535 bytes, then delivers it to a victim (e.g., via a shared dataset, download, or data-processing pipeline). When the victim runs a libLAS tool such as lasinfo, las2las, or las2txt against the file, the truncated 16-bit buffer size causes attacker-controlled bytes to be written past the heap buffer, corrupting memory and crashing the tool. No public exploit code was identified in the provided references, though a detailed technical writeup is available.

This Month Plan within 30 days. Why: Vendor states no customer action required.
No patch listed yet

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

Alert me

AnalysisAIv1 – Oct 18, 2026

Heap out-of-bounds write in libLAS through 1.8.1 allows attackers to corrupt memory when a victim opens a crafted .las file containing a LASSchema variable length record whose declared schema exceeds 65535 bytes, causing crashes and limited integrity impact. The flaw is local and requires user interaction-the malicious file must be processed by libLAS-consuming tools such as lasinfo, las2las, or las2txt-and no authentication is needed. It is a moderate, not urgent, priority; no public exploit was identified at time of analysis.

RemediationAI

No vendor-released patch was identified at time of analysis. Until a fix is available, avoid opening untrusted .las files with libLAS 1.8.1 or earlier and with tools such as lasinfo, las2las, and las2txt; restrict these tools to trusted inputs or disable automated pipelines that parse externally supplied LAS files. Add a pre-processing validation step that inspects LASSchema VLRs and rejects any declared schema length greater than 65535 bytes before libLAS parses the file, and run parsing in a sandboxed low-privilege process with limited memory to contain crashes-validation adds pipeline complexity and sandboxing adds overhead but reduces exposure. Monitor the VulnCheck advisory (https://www.vulncheck.com/advisories/liblas-through-1.8.1-heap-out-of-bounds-write-via-lasschema-vlr) and upstream libLAS sources for a patched release, and consider migrating untrusted-file parsing to a maintained LAS implementation if libLAS remains unpatched.

Affected VersionsENISA

libLAS 0 ≤1.8.1

Affected Packages

euvd liblas 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

libLAS is a C/C++ library for reading and writing ASPRS LAS LiDAR point cloud files. In the point record reader, the schema byte size used to size the point buffer is truncated to 16 bits, so a LASSchema VLR declaring a schema larger than 65535 bytes can cause an undersized heap allocation; subsequent point parsing writes attacker-controlled bytes beyond that buffer. This is CWE-787 (out-of-bounds write), manifesting as memory corruption and crashes in utilities such as lasinfo, las2las, and las2txt. The CPE cpe:2.3:a:liblas:liblas:*:*:*:*:*:*:*:* covers libLAS versions through 1.8.1; the referenced vulnerable code paths are in src/detail/reader/reader.cpp and src/header.cpp.

Know when Liblas 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

File is parsed locally so AV:L; no auth needed (PR:N); victim must open the crafted file (UI:R); outcome is mainly a crash (A:H) with limited integrity (I:L) and no confidentiality impact.

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

libLAS through 1.8.1 contains a heap out-of-bounds write vulnerability in the point record reader caused by truncating the schema byte size to 16 bits when sizing the point buffer. Attackers can craft a .las file with a LASSchema variable length record whose schema exceeds 65535 bytes, so tools like lasinfo, las2las, or las2txt write attacker-controlled bytes past the heap buffer, causing memory corruption and crashes.

Threat Intelligence Overview

Prevalence
Low
niche, effectively retired LiDAR/geospatial library, limited enterprise 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 N/A
Patch available No
Active threat No
Deciding rule
Vendor states no customer action required
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

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

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