CVE-2026-7405

Executive Summary

CVE-2026-7405 is an Out-of-Bounds (OOB) Read vulnerability in the TIFF image parsing library used within certain Autodesk products during image import functionality. A maliciously crafted TIF file can trigger a memory read past the bounds of an allocated buffer, leading to a denial-of-service (DoS) condition via application crash. The vulnerability is rated Medium severity with a CVSS score of 5.5, and per current patch intelligence, there is no evidence of a vendor fix being released. As of this writing, the CVE is NOT listed in CISA's Known Exploited Vulnerabilities (KEV) catalog, and no public proof-of-concept code has been observed. Organizations utilizing Autodesk products for engineering, architecture, or media design must treat untrusted TIF files as high-risk until patches or robust mitigations are deployed.

Technical Analysis

The vulnerability resides in the image handling library employed by multiple Autodesk applications (e.g., AutoCAD, Revit, Maya, 3ds Max) when parsing TIFF file format structures during the image import process. The root cause is a classic CWE-125 (Out-of-bounds Read) flaw triggered during the parsing of TIFF directory entries (IFD — Image File Directory) and associated tag data.

Mechanism: A TIFF file begins with an 8-byte header containing the byte-order marker (II/MM) and the offset to the first IFD. Each IFD contains a count of entries, followed by an array of 12-byte entries. Each entry (tag) encodes: Tag ID (2 bytes), Type (2 bytes), Count (4 bytes), and Value/Offset (4 bytes). The vulnerable parsing logic fails to adequately validate the Count field against the actual remaining file size or internal buffer boundaries before performing read operations.

Attack Surface Details:

• Trigger Vector: The parsing occurs when a user opens or imports a TIF file. The flaw activates when a crafted IFD entry declares a Count value that causes the parser to read beyond the allocated buffer for that tag's data.
• No Remote Code Execution: The vulnerability is read-only. It does not permit data corruption or code injection. The primary consequence is an unhandled exception or segfault in the parsing thread, crashing the application.
• Attack Complexity: The attack requires the victim to open a malicious file (User Interaction: Required). It is local in scope (AV:L). The high availability impact (A:H) reflects the guaranteed crash when a specific malformed condition is met, such as a delta predictor in the LZW decompression path reading out of bounds.
• Lack of Validation: The parsing library does not re-validate the computed offsets and sizes after initial header parsing, allowing an attacker to create a file that passes the initial validation but fails during deep tag value processing.

Code-Level Rationale: The vulnerable function likely appears similar to TIFFReadDirectory() in libtiff-style implementations, where an assumption about tag value sizes leads to a TIFFFetchNormalTag() or memcpy/ReadRawStrip operation without adequate checks. The absence of bounds checking on the tag's Count multiplied by the data type size leads directly to the OOB read.

Exploitation Scenarios

This is a client-side file-format vulnerability. A malicious actor crafts a TIF file and delivers it via phishing email, a compromised website, or a file-sharing service. The following is a step-by-step chain of events:

1. Reconnaissance and Delivery: An attacker identifies a target organization using Autodesk products (e.g., firms advertising AutoCAD usage on engineering forums or LinkedIn). The attacker crafts a weaponized TIF file and embeds it in an email PDF attachment (via a link) or as a direct .tif file. The email is socially engineered to appear as a project drawing or a photo from a client.

2. Weaponization (File Crafting): Using a hex editor or Python scripting (e.g., struct library), the attacker constructs a valid base TIFF file. They then modify the IFD entry for a specific tag. For a known pattern, the attacker alters the Count field of the StripOffsets (Tag 273) or StripByteCounts (Tag 279) entry to a value far larger than the actual file size (e.g., 0xFFFFFFFF). The malformed offset calculation ensures the memcpy operation in the parser attempts to read a 4GB "strip" from a 10KB file, walking past the heap buffer and causing a crash.

3. Execution and Trigger: The victim opens the file. During the automatic image import preview generation in AutoCAD, or during the texture application in 3ds Max, the parser hits the malformed IFD. The arithmetic overflows internally, and the read operation segfaults the process.

4. Post-Exploitation Impact: The application terminates, and any unsaved user work is lost. In a shared VDI or network-license environment, the crash may leave stale license tokens, impacting concurrent user sessions. An attacker can repeat this to repeatedly DoS a specific engineer's workstation or a rendering farm node.

Additional Scenario (Proximity/Internal): An attacker with access to a network share where project files are stored (e.g., on a Siemens Teamcenter or Autodesk Vault server) replaces a standard texture.tif with the malicious file. When any client downloads and opens the project, the crash occurs, effectively blocking the rendering pipeline for the entire team.

Impact Assessment

CVSS Subscore Breakdown (5.5 Medium):

• AV:L (Local): Requires user interaction to open a file locally.
• AC:L (Low): No special conditions beyond file opening; the crafted file is easy to produce.
• PR:N (None): No privileges needed to attempt the attack.
• UI:R (Required): The user must open the file.
• S:U (Unchanged): The compromise is contained to the vulnerable process.
• C/I:N (None): No confidentiality or integrity loss.
• A:H (High): Total loss of availability (application crash).

Business Impact:

• Operational Disruption: In a design environment, a crash leads to project delays. Autodesk tools manage complex projects with significant startup times (1-5 minutes). Repeated crashes render a workstation unusable.
• Supply Chain Risk: If the flaw is in a common library shared among products (e.g., the ADSK_ImageIO core), a single malicious file can crash multiple Autodesk titles (AutoCAD, Civil 3D, Inventor, Maya). This extends the blast radius.
• Data Integrity: While no direct data corruption occurs, the crash may lead to temporary file corruption if the application was in the middle of a save operation (though this is secondary).
• Zero Epoch Risk: As there is no patch and no workaround from Autodesk, the vulnerability remains exploitable indefinitely, making it a persistent threat in air-gapped environments that are updated infrequently.

Detection Guidance

Sigma Rule

The following rule detects processes named for Autodesk products that crash or report OOB read errors after opening a TIF file.

title: Autodesk TIF Parsing Out-of-Bounds Read
id: 7f3b2d1e-8c6f-4a5b-9e0d-2c4f6a8b1e00
status: experimental
description: Detects crash events in Autodesk products following image parsing, indicating possible exploitation of CVE-2026-7405.
logsource:
  category: process_creation
  product: windows
detection:
  selection_autodesk:
    Image|endswith:
      - '\acad.exe'
      - '\revit.exe'
      - '\3dsmax.exe'
      - '\maya.exe'
      - '\inventor.exe'
      - '\civil3d.exe'
  selection_crash:
    EventID: 1000
    Provider_Name: 'Application Error'
    Details|contains: 'Exception code: 0xc0000005'  # Access Violation
  condition: selection_autodesk and selection_crash
level: medium
falsepositives:
  - Legitimate crashes due to corrupt files or memory pressure.
  - Plugins causing access violations.
fields:
  - Image
  - CommandLine
  - TargetFilename
tags:
  - attack.t1204.001
  - cve.2026.7405

YARA Rule

This rule scans TIF files for byte patterns indicative of the malformed IFD structure used in known exploit attempts.

rule Autodesk_TIF_OOBRead_CVE_2026_7405 {
    meta:
        author = "ValterSIT Threat Intel"
        description = "Detects malformed TIFF IFD entries with excessive count values targeting Autodesk products"
        cve = "CVE-2026-7405"
        date = "2025-01-01"
    strings:
        // TIFF header (Little Endian)
        $header_le = { 49 49 2A 00 }
        // TIFF header (Big Endian)
        $header_be = { 4D 4D 00 2A }
        // StripOffsets tag (273 = 0x0111)
        $tag_stripoff = { 11 01 }
        // StripByteCounts tag (279 = 0x0117)
        $tag_bytecounts = { 17 01 }
        // Excessively large count value (>= 0xFFFFFF00)
        $large_count = { 00 FF FF FF }
    condition:
        ( $header_le at 0 or $header_be at 0 ) and
        ( ( $tag_stripoff at any and $large_count in (filesize - 16 .. filesize) ) or
          ( $tag_bytecounts at any and $large_count in (filesize - 16 .. filesize) ) )
}

Suricata IDS Rule

This rule detects the initial network delivery of potentially malicious TIF files from external sources.

alert http any any -> $HOME_NET any (msg:"CVE-2026-7405 Autodesk TIF OOB Read Deliver"; flow:to_client,established; fileext:"tif" or fileext:"tiff"; content:"II*\x00"; offset:0; depth:4; content:"|FF FF FF|"; within:64; reference:cve,2026-7405; sid:1007405; rev:1;)

Elastic Detection

EQL rule correlating file creation events with subsequent application crash logs.

sequence with maxspan=30s
  [ file where event.action == "creation" and
      file.extension in ("tif", "tiff") and
      process.name in ("acad.exe", "revit.exe", "3dsmax.exe", "maya.exe") ]
  [ process where event.type == "end" and
      process.name in ("acad.exe", "revit.exe", "3dsmax.exe", "maya.exe") and
      process.exit_code == 3221225477 ] // 0xC0000005

Splunk SPL Query

index=windows sourcetype=WinEventLog:Application EventCode=1000 "Exception code: 0xc0000005"
| search "acad.exe" OR "revit.exe" OR "3dsmax.exe" OR "maya.exe"
| eval correlation_id=md5(_time, host, user)
| join type=inner correlation_id
    [ search index=filesystem file_name=*.tif OR *.tiff
        | eval correlation_id=md5(_time, host, user)
        | eval TIF_File_Opened="true" ]
| table _time, host, user, Image, FaultingModule, TIF_File_Opened
| sort -_time

Wazuh OSSEC Rule

<rule id="774574" level="10">
  <if_sid>18100</if_sid> <!-- Application Crash Event -->
  <field name="win.eventdata.image">\.\\acad\.exe|\.\\revit\.exe|\.\\3dsmax\.exe|\.\\maya\.exe</field>
  <match>0xc0000005</match>
  <description>CVE-2026-7405: Potential TIF parsing OOB Read in Autodesk software</description>
  <group>cve-2026-7405, autodesk, crash,</group>
  <mitre>
    <id>T1204.001</id>
  </mitre>
</rule>

Mitigation & Patch Guidance

Patch Status: The vulnerability is currently UNPATCHED. The MITRE CNA has indicated that Patch Confidence: 0/4 and no vendor fix exists. The Affected Versions: [] field implies that Autodesk has not confirmed a specific affected version range, which further complicates inventory tracking. Do not assume any version is immune.

1. Immediate Mitigations

• Application Hardening: Disable automatic image preview generation in all Autodesk products. In AutoCAD, set PREVIEWFROMSHEETSET to 0. In 3ds Max, disable "Load Texture in Background" in preferences.
• File Integrity Policy: Enforce a strict policy where TIF/TIFF files are re-saved internally via a dedicated validation tool (e.g., ImageMagick with -define tiff:validate=true) before being opened in Autodesk products. Any file that fails validation is quarantined.
• Network Control: Use email security gateways to strip TIF/TIFF attachments or quarantine them for manager approval. Implement web filtering to block downloads from untrusted domains.
• User Education: Alert staff to the specific risk of TIF files from clients and third-party vendors. Emphasize that even legitimate-looking files can be weaponized.

2. Patch/Upgrade Steps

• Monitor Vendor Bulletins: Until Autodesk releases an advisory or patch, subscribe to the Autodesk Security Advisory RSS feed. The fix is expected to be an update to the core AdskImageIO.dll or similar library, distributed via the Autodesk Desktop App.
• Version Pinning: Once a patched version is released, update all deployments immediately. Use the Autodesk Access portal to manage deployments and pin versions to the patched release.
• Temporary Alternative: If the target product has an alternative file format for import (e.g., PNG, JPEG for textures, or DXF for geometry), mandate the use of these formats until a patch is available.

3. Long-Term Hardening

• Least Privilege: Run Autodesk products under standard user accounts without local admin rights. This limits the impact of a future OOB write vulnerability that could escalate into code execution.
• Virtualization: Deploy vulnerable Autodesk applications in a virtualized sandbox (e.g., Microsoft App-V or VMware ThinApp) or on remote desktop sessions that can be instantly rolled back after a crash.
• File Reputation Monitoring: Integrate a file-based sandboxing solution (e.g., FireEye or Cuckoo) into the email pipeline to detonate all TIF files in a contained environment before they reach the user.
• Incident Response Readiness: Prepare runbooks for rapid response to confirmed exploitation attempts, including capturing the malicious file, isolating the host, and rotating credentials if the crash is accompanied by unusual process activity.

References

1. NVD Entry (Authoritative): https://nvd.nist.gov/vuln/detail/CVE-2026-7405
2. MITRE CVE Entry: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2026-7405
3. Autodesk Security Advisories Page (Monitor for Update): https://knowledge.autodesk.com/security-advisories
4. CISA KEV Catalog (Not Listed, but Check Regularly): https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Threat Actor Campaigns / Exploitation Evidence: As of this writing, there are no publicly documented campaigns or exploit-in-the-wild evidence linking CVE-2026-7405 to specific threat actors. The vulnerability remains a latent risk for DoS attacks, and the onus is on defenders to proactively mitigate the risk via the technical controls described above.

Report compiled by the ValterSIT Threat Intelligence Team. Classification: TLP:CLEAR