CVE-2026-16465

Executive Summary

CVE-2026-16465 is an out-of-bounds read vulnerability in Autodesk AutoCAD when parsing specially crafted DWG or DXF files. A remote attacker can entice a user to open a malicious file, leading to a crash (denial of service) or leakage of sensitive memory contents. With a CVSS base score of 6.1 (Medium), the flaw does not enable remote code execution, but can expose confidential data or disrupt operations. No patch is currently available. This report details the technical mechanics, exploitation scenarios, detection methods, and mitigation steps.

As this vulnerability involves a desktop application (Autodesk AutoCAD) and not a package manager ecosystem, no supply chain analysis is applicable.

CVSS Breakdown & Threat Level

• Base Score: 6.1 – Medium
• Vector (estimated): CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:H
• Attack Vector (AV): Local – the attacker must deliver a file to the target system
• Attack Complexity (AC): Low – no special conditions required
• Privileges Required (PR): None – user only needs to open the file
• User Interaction (UI): Required – victim must open the malicious DWG/DXF
• Scope (S): Unchanged – vulnerability affects only the vulnerable component
• Confidentiality (C): High – memory contents may be leaked
• Integrity (I): None – no data modification
• Availability (A): High – crash causes denial of service

Deep Dive & Mechanics

The DWG and DXF file formats are binary and text‑based storage formats used by AutoCAD to represent 2D/3D geometry, metadata, and object properties. Parsing such files involves reading variable‑length records, handles, and entity data.

CVE-2026-16465 is an out‑of‑bounds read (CWE-125) that occurs during the parsing routine when a size field or offset in a malformed file is larger than the allocated buffer. The parser trusts attacker‑supplied length values without proper validation, causing it to read memory beyond the intended buffer boundary.

The vulnerability can be triggered by:

• A DWG file containing a section record with an invalid length.
• A DXF file with an oversized extended data (XDATA) chunk.
• Malformed object handle sequences where index values reference outside the object table.

The result of an OOB read is twofold:

1. Information disclosure: out‑of‑bounds memory containing other process data (e.g., addresses, strings, credentials) may be returned to the attacker through error messages or serialised output.
2. Crash: reading unmapped memory causes an access violation, terminating AutoCAD.

Vulnerable vs. Patched Code

No patch is currently available. The vulnerable code is likely in the acdb*.dll or AcDb* library responsible for file parsing. A typical vulnerable snippet (pseudocode):

// Vulnerable code
void ParseEntity(Stream* s) {
    uint32_t dataSize = s->ReadUInt32(); // attacker controlled
    char* buffer = new char[256];        // fixed size
    s->Read(buffer, dataSize);           // OOB read if dataSize > 256
}

A patched version would include a bounds check:

// Patched code
void ParseEntity(Stream* s) {
    uint32_t dataSize = s->ReadUInt32();
    const uint32_t maxSize = 256;
    if (dataSize > maxSize) {
        // handle error, reject file
        return;
    }
    char* buffer = new char[maxSize];
    s->Read(buffer, dataSize);
}

Until Autodesk releases an update, no code‑level fix is available.

Exploitation & Lab Setup

Red Team (Exploitation)

Preconditions:

• Attacker crafts a malicious DWG or DXF file.
• Victim uses Autodesk AutoCAD (any affected version) and opens the file.

Steps:

1. Create a valid DWG/DXF base template.
2. Locate a section with a length field (e.g., DWG header length, DXF group code 62 or extended data).
3. Overwrite the length with a value larger than the actual buffer size (e.g., 0xFFFFFFFF).
4. Optionally include sentinel values in memory to exfiltrate after the crash.

Example DXF snippet (malformed):

  0
SECTION
  2
HEADER
  9
$ACADVER
  1
AC1027
  0
ENDSEC
  0
SECTION
  2
ENTITIES
  0
LINE
  5
10
 10
0.0
 20
0.0
 30
0.0
 11
100.0
 21
100.0
 31
0.0
  0
ENDSEC
  0
EOF

Attackers can add oversized XDATA or manipulate handle values. A proof‑of‑concept binary file is not provided due to lack of public exploit code.

Lab Setup (safe testing):

• Install AutoCAD (trial) in a sandbox VM.
• Use fuzzing tools like boofuzz to mutate valid DWG files.
• Monitor for crashes with WinDbg or GDB.

Blue Team (Defense)

• Detection: Monitor for unexpected AutoCAD crashes using Windows Event Log (Event ID 1000, 1001). Correlate with recent DWG/DXF file downloads.
• Prevention:
  • Use file scanning tools (e.g., ClamAV with signatures for known malformed DWG).
  • Enable Microsoft Defender Attack Surface Reduction rules that block Office apps from creating child processes (though AutoCAD is not Office, similar rules can be created).
  • Restrict execution of AutoCAD to only users who require it; enforce AppLocker.
• Response: If a crash occurs, isolate the file and submit to sandbox analysis. Check memory dumps for leaked data.

Indicators of Compromise (IOCs)

• File Hashes: None publicly available; but any file causing an AutoCAD crash with OOB read in memory.
• YARA Rule (see Detection Engineering) can match file patterns.
• Network: No network IOCs for this local vulnerability.
• Process: AutoCAD process (acad.exe) crash dump in %LOCALAPPDATA%\CrashDumps.
• Registry: AutoCAD may write crash info to HKLM\Software\Autodesk\AutoCAD\R*.*\ACAD-*:...\CrashReporter.

Detection Engineering

YARA Rule

rule CVE_2026_16465_DWG_OOB_Read {
    meta:
        description = "Detects malformed DWG files triggering OOB read in AutoCAD"
        author = "Valters IT"
        date = "2025-04-09"
        cve = "CVE-2026-16465"
        hash = "SHA256: sample"

    strings:
        // Look for DWG magic header
        $dwg_magic = "AC10" // AC1015-AC1027
        $dxf_magic = { 30 30 } // '00' as first bytes of DXF ASCII version
        // Suspiciously large length fields (DWG section size > 1MB)
        $big_len = { FF FF 03 00 } // example: little endian 0x0003FFFF = 262143 bytes

    condition:
        ($dwg_magic or $dxf_magic) and $big_len at (0..1024)
}

Sigma Rule (Windows Event Log)

title: AutoCAD Crash Due to Parsing Malicious DWG/DXF
id: 5c9b8f2a-3c4e-4f1a-b2c3-4d5e6f7a8b9c
status: experimental
description: Detects AutoCAD process crashes that may indicate exploitation of CVE-2026-16465
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2026-16465
author: Valters IT
date: 2025-04-09
logsource:
    product: windows
    service: application
detection:
    selection:
        EventID: 1000
        Provider Name: 'Application Error'
        Data: 'acad.exe'
    condition: selection
falsepositives:
    - Legitimate AutoCAD crashes due to other bugs
level: medium

Suricata Rule (Network - for file delivery detection)

alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"CVE-2026-16465 Potential Malicious DWG/DXF Download"; flow:to_client,established; file_store; file.magic:"AutoCAD Drawing"; file.size:>0; classtype:attempted-user; sid:202616465; rev:1;)

Note: Since the vulnerability is local file parsing, network detection is less effective unless combined with HTTP/TFTP file transfer monitoring.

Remediation & Mitigation

• Vendor Patch: None available. Monitor Autodesk security advisories for future updates.
• Mitigations:
  • Disable AutoCAD from automatically opening DWG/DXF from untrusted sources.
  • Use Group Policy to block execution of AutoCAD for non‑essential users.
  • Implement file whitelisting for known‑good DWG templates.
  • When opening files from external parties, use a dedicated sandbox environment or convert to a safer format (e.g., PDF) first.
  • Apply the latest AutoCAD updates (if any) and enable the built‑in file validation feature (if available).
• Workaround: Instruct users to avoid opening DWG/DXF files from untrusted senders. Use endpoint protection with behavioral analysis.

Valters IT – Cyber Threat Intelligence & DevSecOps