CVE-2025-3000
PyTorch 2.6.0 torch.jit.script memory corruption vulnerability.
- CVSS 4.8
- CWE-119
- Memory Corruption
- Local
A vulnerability classified as critical has been found in PyTorch 2.6.0. This affects the function torch.jit.script. The manipulation leads to memory corruption. It is possible to launch the attack on the local host. The exploit has been disclosed to the public and may be used.
- CWE
- CWE-119
- CVSS base score
- 4.8
- Published
- 2025-03-31
- OWASP
- A04 Insecure Design
- Orthogonal defect classification
- Algorithm
- Code defect classification
- Incorrect Functionality
- Category
- Memory Corruption
- Subcategory
- Buffer Overflows
- Accessibility scope
- Local
- Impact
- Arbitrary Code Execution
- Affected component
- PyTorch
- Fixed by upgrading
- Yes
Solution
Upgrade to PyTorch >= 2.6.1.
Vulnerable code sample
import torch
import io
# WARNING: This code is for educational purposes only and demonstrates a potential vulnerability.
# DO NOT use this code in a production environment. Exploiting vulnerabilities is illegal and unethical.
# This code is a SIMPLIFIED representation of a potential memory corruption issue and may not perfectly
# replicate the specifics of CVE-2025-3000. It aims to illustrate the general concept of how
# malicious input could potentially cause problems in `torch.jit.script`.
def simulate_vulnerable_script(model_def):
"""
Simulates the vulnerable torch.jit.script compilation.
Args:
model_def: A string containing the Python code defining the model.
"""
try:
# This is a simplified example, assuming the vulnerability lies in how
# torch.jit.script handles certain types of model definitions.
# In reality, the vulnerability might be in a specific code path within
# the compilation process.
# Simulate writing the model definition to a file (or string buffer)
with io.StringIO(model_def) as model_file:
# Simulate parsing the model definition. A real vulnerability
# might be triggered during this parsing or during a subsequent
# compilation stage.
exec(model_file.read(), globals())
# Assume that a model named 'MaliciousModel' is defined
model = MaliciousModel()
# Trigger the torch.jit.script compilation. This is where the
# vulnerability is assumed to be.
scripted_model = torch.jit.script(model)
print("Model successfully scripted (simulated).")
except Exception as e:
print(f"Error during scripting: {e}")
# Example of a potentially malicious model definition. The actual trigger
# for a memory corruption vulnerability would likely be more complex and
# subtle. This example just uses a large Tensor to potentially cause problems.
malicious_model_def = """
import torch
import torch.nn as nn
class MaliciousModel(nn.Module):
def __init__(self):
super().__init__()
self.large_tensor = torch.randn(1000, 1000, 1000) # Large tensor
self.linear = nn.Linear(1000, 1000) # Example layer
def forward(self, x):
x = self.linear(x)
return x
"""
if __name__ == "__main__":
simulate_vulnerable_script(malicious_model_def)Patched code sample
# This is a hypothetical example and may not directly reflect the actual fix for CVE-2025-3000.
# It demonstrates a potential memory safety improvement in torch.jit.script.
def safe_jit_script(func):
"""
A hypothetical safe version of torch.jit.script that mitigates potential
memory corruption vulnerabilities. This is NOT the actual CVE-2025-3000 fix,
but an example of how memory safety could be improved.
Args:
func: The function to be compiled with torch.jit.
Returns:
A compiled function using torch.jit.script, but with added memory safety checks.
"""
import torch
def wrapped_func(*args, **kwargs):
# 1. Input Validation and Sanitization: Check the types and sizes of inputs
# to prevent unexpected memory allocations or buffer overflows.
for arg in args:
if not isinstance(arg, (int, float, torch.Tensor)):
raise ValueError("Unsupported argument type. Only int, float, and torch.Tensor are allowed.")
if isinstance(arg, torch.Tensor):
if arg.numel() > 100000: # Limit tensor size to prevent excessive allocation
raise ValueError("Tensor size exceeds allowed limit.")
# 2. Memory Limits: Set a limit on the maximum memory that the compiled function can allocate.
# This is a simplified example; a real implementation would integrate with PyTorch's
# memory management system.
max_memory_allocation = 100 * 1024 * 1024 # 100MB
current_memory_allocation = 0 # Placeholder
def allocate_memory(size):
nonlocal current_memory_allocation
if current_memory_allocation + size > max_memory_allocation:
raise MemoryError("Exceeded maximum memory allocation limit.")
current_memory_allocation += size
# In real code, this would be where memory is actually allocated
# 3. Safe Data Structures: Use data structures that provide bounds checking and memory safety
# features (if available within the torch.jit.script context). This example shows using a list comprehension
# with size limits on its contents.
safe_list = [x for x in args if isinstance(x, int) and x < 1000] #limit integer list contents
# 4. Error Handling: Add comprehensive error handling to catch potential memory errors
# and prevent the program from crashing or exhibiting undefined behavior.
try:
result = func(*args, **kwargs) # Execute original function
# post processing to clean up memory
return result
except MemoryError as e:
print(f"Memory allocation failed: {e}")
raise # Re-raise the exception
except Exception as e:
print(f"An error occurred during execution: {e}")
raise
# Use torch.jit.script to compile the wrapped function
return torch.jit.script(wrapped_func)Payload
import torch
# Craft a malicious script that triggers memory corruption
malicious_script = """
def forward(self, x):
# This is a placeholder, the actual exploit would manipulate memory
# during the JIT compilation process, which is difficult to demonstrate
# directly in a simplified example.
# The vulnerability likely involves overflowing a buffer or writing to an
# invalid memory location during graph construction or optimization.
a = torch.zeros([100000000]) # Allocate large memory block
del a
b = torch.ones([100]) # Allocate another block
return b
"""
try:
# Attempt to JIT compile the malicious script
@torch.jit.script
class MaliciousModule(torch.nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
a = torch.zeros([100000000]) # Allocate large memory block
del a
b = torch.ones([100]) # Allocate another block
return b
model = MaliciousModule()
input_tensor = torch.randn(10) # Example input
output = model(input_tensor)
print("Exploit attempt completed (if no crash, it might not be exploitable without specific hardware/setup)")
except Exception as e:
print(f"Exploit attempt failed: {e}")
Cite this entry
@misc{vaitp:cve20253000,
title = {{PyTorch 2.6.0 torch.jit.script memory corruption vulnerability.}},
author = {Bogaerts, Fr\'ed\'eric and Ivaki, Naghmeh and Fonseca, Jos\'e},
year = {2025},
note = {VAITP Python Vulnerability Dataset, entry CVE-2025-3000},
howpublished = {\url{https://netpack.pt/vaitp/vulnerability/CVE-2025-3000/}}
}
Introducing the "VAITP dataset": a specialized repository of Python vulnerabilities and patches, meticulously compiled for the use of the security research community. As Python's prominence grows, understanding and addressing potential security vulnerabilities become crucial. Crafted by and for the cybersecurity community, this dataset offers a valuable resource for researchers, analysts, and developers to analyze and mitigate the security risks associated with Python. Through the comprehensive exploration of vulnerabilities and corresponding patches, the VAITP dataset fosters a safer and more resilient Python ecosystem, encouraging collaborative advancements in programming security.
The supreme art of war is to subdue the enemy without fighting.
Sun Tzu – “The Art of War”
:: Shaping the future through research and ingenuity ::
