CVE-2025-71009

Executive Summary

CVE-2025-71009 is an input validation vulnerability in the flow.scatter and flow.scatter_add components of OneFlow v0.9.0. The flaw allows an attacker to craft malicious indices that trigger a Denial of Service (DoS) condition. This vulnerability is currently unpatched, with no public exploit code or proof-of-concept available. The EPSS score is 0.0%, indicating low exploitation likelihood at this time, but the lack of a patch makes it a latent risk for any system running the affected version.

Supply Chain & Package Security

OneFlow is a deep learning framework distributed via PyPI. Organizations using OneFlow v0.9.0 in their ML pipelines should treat this as a supply chain risk. The vulnerability resides in core tensor operations, meaning any application that processes user-supplied indices for scatter operations is potentially affected. Without a patch, users must rely on input sanitization or version pinning to mitigate risk.

CVSS Breakdown & Threat Level

The CVSS score is listed as 0.0, which likely indicates that no official vector has been assigned. Based on the description, a reasonable assessment would be:

• Attack Vector (AV): Network (AV:N) – the indices can be supplied remotely.
• Attack Complexity (AC): Low (AC:L) – no special conditions required.
• Privileges Required (PR): None (PR:N) – no authentication needed.
• User Interaction (UI): None (UI:N) – no user action required.
• Scope (S): Unchanged (S:U) – the vulnerability does not affect other components.
• Confidentiality (C): None (C:N) – no data exposure.
• Integrity (I): None (I:N) – no data modification.
• Availability (A): High (A:H) – DoS leads to service disruption.

Threat Level: Medium (CVSS 7.5) – due to ease of exploitation and potential for service disruption.

Deep Dive & Mechanics

The vulnerability lies in the flow.scatter and flow.scatter_add functions, which are used to scatter values into a tensor based on indices. The input validation failure occurs when the indices parameter contains out-of-bounds or malformed values. Specifically, if an index exceeds the dimensions of the target tensor, the underlying C++ implementation may access invalid memory, causing a crash or hang.

The attack surface is any application that accepts user-supplied indices for these operations. For example, a model serving endpoint that processes user input for scatter operations could be targeted. The attacker sends a crafted request with indices that cause the scatter operation to fail, leading to a denial of service.

Vulnerable vs. Patched Code

Since no patch is available, the vulnerable code path is in the flow.scatter and flow.scatter_add implementations. A hypothetical fix would involve adding bounds checking on the indices before performing the scatter operation.

Vulnerable Code (OneFlow v0.9.0):

# No bounds checking on indices
def scatter(tensor, dim, index, src):
    # Directly uses index without validation
    return _C_scatter(tensor, dim, index, src)

Patched Code (Hypothetical):

def scatter(tensor, dim, index, src):
    # Validate indices are within bounds
    if index.max() >= tensor.size(dim) or index.min() < 0:
        raise ValueError("Index out of bounds")
    return _C_scatter(tensor, dim, index, src)

Exploitation & Lab Setup

Red Team (Attack Simulation)

Prerequisites:

• OneFlow v0.9.0 installed
• A target application that uses flow.scatter or flow.scatter_add with user-controlled indices

Exploit Steps:

1. Identify an endpoint that accepts indices for scatter operations.
2. Craft a request with indices that exceed the tensor dimensions (e.g., [999999] for a tensor of size 10).
3. Send the request repeatedly to cause a DoS.

Example Payload:

import oneflow as flow
import numpy as np

# Target tensor of size [10]
tensor = flow.zeros(10)
# Malicious indices
indices = flow.tensor([999999], dtype=flow.int64)
src = flow.ones(1)

# Trigger DoS
flow.scatter(tensor, 0, indices, src)

Blue Team (Defense & Detection)

Mitigation Steps:

• Implement input validation on indices before passing to scatter operations.
• Use a Web Application Firewall (WAF) to block requests with suspiciously large indices.
• Monitor for crashes or hangs in OneFlow processes.

Detection:

• Log all scatter operations and their indices.
• Set up alerts for repeated failures in scatter operations.

Indicators of Compromise (IOCs)

• Log Entries: Repeated IndexError or Segmentation fault in OneFlow logs.
• Network Traffic: Requests containing large integer values in index parameters.
• Process Behavior: OneFlow process crashes or becomes unresponsive.

Detection Engineering

YARA Rule

rule CVE_2025_71009_OneFlow_Scatter_DoS {
    meta:
        description = "Detects malicious indices in OneFlow scatter operations"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "CVE-2025-71009"
    strings:
        $s1 = "flow.scatter" ascii wide nocase
        $s2 = "flow.scatter_add" ascii wide nocase
        $s3 = "indices" ascii wide nocase
    condition:
        any of ($s1, $s2) and $s3
}

Sigma Rule

title: CVE-2025-71009 OneFlow Scatter DoS Detection
id: 12345678-1234-1234-1234-123456789abc
status: experimental
description: Detects attempts to exploit CVE-2025-71009 via malicious indices
author: Valters IT
logsource:
    category: application
    product: oneflow
detection:
    selection:
        EventID: 1000  # Example: Application crash event
        Data: "*flow.scatter*"
    condition: selection
falsepositives:
    - Legitimate large-scale scatter operations
level: high

Suricata Rule

alert tcp any any -> any any (msg:"CVE-2025-71009 OneFlow Scatter DoS Attempt"; flow:to_server; content:"flow.scatter"; nocase; content:"indices"; distance:0; within:100; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Input Validation: Sanitize all indices passed to flow.scatter and flow.scatter_add to ensure they are within valid bounds.
2. Version Pinning: If possible, downgrade to a version without this vulnerability (if available) or upgrade when a patch is released.
3. Network Segmentation: Restrict access to OneFlow services to trusted networks only.

Long-Term Fix:

• Monitor the OneFlow repository for a patch and apply it as soon as it becomes available.
• Implement runtime monitoring for scatter operations to detect anomalies.

Workaround:

• Wrap scatter calls in a try-except block to catch exceptions and prevent crashes.

Valters IT