Skip to content

Latest commit

 

History

History
58 lines (45 loc) · 6.46 KB

threat-modeling.md

File metadata and controls

58 lines (45 loc) · 6.46 KB

Threat Model Analysis for taichi-dev/taichi

Threat: TI_INJ_001: Code Injection in Dynamically Generated Kernels

  • Threat: TI_INJ_001: Code Injection in Dynamically Generated Kernels

    • Description: An attacker provides malicious input that is used to construct Taichi kernel code. If the application uses user-provided strings to build a Taichi expression (e.g., within a ti.func or ti.kernel decorator), the attacker could inject arbitrary Taichi code. This injected code could access/modify unauthorized data, call system functions (if exposed), or interact with the OS.
    • Impact: Arbitrary code execution within the Taichi runtime. This could lead to complete compromise of the application, data exfiltration, data corruption, or denial of service. If Taichi runs with elevated privileges, the attacker could gain those privileges.
    • Affected Taichi Component: taichi.lang.kernel_impl.Kernel, taichi.lang.expr.Expr, any code that uses string formatting or concatenation to build Taichi code. Specifically, any function/method that accepts user input and uses it directly/indirectly within a ti.kernel or ti.func decorator.
    • Risk Severity: Critical
    • Mitigation Strategies:
      • Avoid Dynamic Kernel Generation: The best mitigation is to avoid dynamically generating Taichi kernel code from user input. Use pre-defined kernels with parameterized inputs.
      • Parameterized Kernels: If dynamic elements are unavoidable, design Taichi code to accept parameters rather than constructing code strings.
      • Strict Input Validation and Sanitization: If dynamic generation is absolutely necessary, implement extremely strict input validation and sanitization. Use a whitelist approach, allowing only known-safe characters and patterns. Reject any input that doesn't conform. Consider a dedicated parsing library.
      • Least Privilege: Run Taichi kernels with the least necessary privileges. Avoid running Taichi with root/administrator access.

Threat: TI_DOS_001: Denial of Service via Memory Exhaustion

  • Threat: TI_DOS_001: Denial of Service via Memory Exhaustion

    • Description: An attacker provides input that causes Taichi to allocate an excessive amount of memory (CPU or GPU). This could be achieved by providing extremely large input arrays or by crafting a Taichi kernel that creates large intermediate data structures (e.g., a kernel that repeatedly appends to a ti.field without bounds).
    • Impact: Denial of service for the application. The application may crash or become unresponsive. In severe cases, it could affect the entire system.
    • Affected Taichi Component: taichi.field, taichi.Matrix, taichi.Vector, any Taichi data structure allocation. The specific backend (CPU, CUDA, Metal, etc.) is also affected.
    • Risk Severity: High
    • Mitigation Strategies:
      • Input Size Limits: Enforce strict limits on the size of input data passed to Taichi kernels. Reject any input that exceeds these limits.
      • Memory Allocation Limits (Runtime): Explore options for limiting the total memory a Taichi kernel can allocate. This might involve modifying the Taichi runtime or using external tools (e.g., cgroups on Linux).
      • Kernel Analysis: Carefully analyze Taichi kernels for potential memory leaks or unbounded allocations. Use profiling tools.
      • Containerization: Run Taichi kernels within containers (e.g., Docker) with memory limits enforced.

Threat: TI_DOS_002: Denial of Service via CPU/GPU Overload

  • Threat: TI_DOS_002: Denial of Service via CPU/GPU Overload

    • Description: An attacker crafts a Taichi kernel that performs an extremely computationally intensive operation, consuming excessive CPU or GPU cycles. This could involve an infinite loop, deep recursion, or an algorithm with high computational complexity.
    • Impact: Denial of service. The application becomes unresponsive, and other processes on the system may be starved of resources.
    • Affected Taichi Component: taichi.lang.kernel_impl.Kernel, any Taichi kernel code. The specific backend (CPU, CUDA, Metal, etc.) is also affected.
    • Risk Severity: High
    • Mitigation Strategies:
      • Execution Time Limits: Impose a time limit on the execution of Taichi kernels. If a kernel exceeds this limit, terminate it. This may require modifications to the Taichi runtime or external monitoring.
      • Kernel Complexity Analysis: Analyze Taichi kernels for potential performance bottlenecks and infinite loops. Use profiling tools.
      • Input Validation: Validate input data to prevent inputs likely to trigger computationally expensive operations.
      • Containerization: Run Taichi kernels within containers with CPU/GPU resource limits.

Threat: TI_VULN_001: Exploitation of Taichi Compiler/Runtime Vulnerability

  • Threat: TI_VULN_001: Exploitation of Taichi Compiler/Runtime Vulnerability

    • Description: An attacker discovers and exploits a vulnerability in the Taichi compiler or runtime (e.g., a buffer overflow, memory corruption, or logic error). The attacker crafts a specific Taichi kernel to trigger the vulnerability.
    • Impact: Varies depending on the vulnerability. Could range from denial of service to arbitrary code execution with the privileges of the Taichi process.
    • Affected Taichi Component: Potentially any part of the Taichi compiler (taichi/codegen, taichi/ir), runtime (taichi/runtime), or backend-specific code.
    • Risk Severity: Critical (if exploitable for code execution), High (if exploitable for DoS)
    • Mitigation Strategies:
      • Keep Taichi Updated: The primary mitigation. Regularly update to the latest stable version of Taichi.
      • Monitor Security Advisories: Subscribe to Taichi's security announcements or mailing lists.
      • Sandboxing (Advanced): Run Taichi kernels in a sandboxed environment (e.g., gVisor, nsjail) to limit the impact.
      • Fuzzing (Advanced): Security researchers may consider fuzzing the Taichi compiler and runtime.