Browse / Unsafe Model Loading and Supply Chain / Code and command execution
Code and command execution
59 records in Unsafe Model Loading and Supply Chain.
- PraisonAI: Unsafe Dynamic Module Loading Leads to Arbitrary Code Execution via tools.py in AgentFlow A workflow directory containing a malicious tools.py is imported and executed without sandboxing when a step resolves a structured output type, ignoring the tool allow setting.
- Docling imports plugin entry points before the allow_external_plugins check Docling imports every installed plugin module before applying the external-plugin restriction, so third-party import-time code runs even when external plugins are disabled.
- NLTK: Missing Post-Download Integrity Verification Allows Malicious Package Injection The NLTK downloader unpacks downloaded archives without checking their hash, so a tampered package can deliver malicious pickle files.
- Flowise: Remote Code Execution Vulnerability in CSVAgent
- Ray: Arbitrary code execution via ray.data.read_webdataset default decoder: pickle.loads(value) and torch.load(weights_only=False)
- PyTorch Lightning allows arbitrary code execution through checkpoint _instantiator hyperparameters
- NLTK Stanford wrapper classes execute untrusted JAR files without verification Five Stanford wrapper classes run user-supplied JAR files through Java without the SHA256 verification added to one sibling class.
- ChromaDB has a code injection vulnerability A model repository with remote code enabled is pulled into a collection update call, letting a user with update permission execute code on the server.
- vLLM's Artifact Pin Decay allows pinned deployments to load unpinned code, weights, and processors Revision pins apply to only some artifacts, so dynamic code, processors and side weights can be loaded from an unpinned revision.
- PraisonAI: Arbitrary code execution via unguarded `spec.loader.exec_module` in `agents_generator.py` - sibling of CVE-2026-44334 Module paths read from YAML configuration are executed through importlib at call sites missed by the earlier environment gate, running attacker-supplied Python code.
- HuggingFace transformers vulnerable to remote code execution A crafted config.json points an internal attention field at a hub repo, so from_pretrained fetches and runs attacker Python without trust_remote_code.
- Cleartext storage of HMAC signing key in Amazon SageMaker Python SDK ModelBuilder/Serve path A signing key readable through cloud describe APIs lets an attacker forge integrity signatures so malicious model artifacts are accepted and run in the serving container.
- Diffusers: TOCTOU Trust Remote Code Bypass A race between the trust check and the load step lets a Hub repository's custom pipeline code run without the trust_remote_code flag.
- ChromaDB Python project has a pre-authentication code injection vulnerability Sending a model repository with trust_remote_code enabled to a collection endpoint makes the server run attacker-supplied Python without authentication.
- Diffusers has a `trust_remote_code` bypass via `custom_pipeline` and local custom components Remote code in a custom pipeline or local model folder runs even when trust_remote_code is false, because the check sits in the download step that those paths skip.
- Ray: Remote Code Execution via Parquet Arrow Extension Type Deserialization
- Keras has an untrusted deserialization vulnerability A crafted .keras archive makes TFSMLayer load an attacker's SavedModel, running code even when safe_mode is enabled.
- MLflow Command Injection vulnerability
- vLLM has Hardcoded Trust Override in Model Files Enables RCE Despite Explicit User Opt-Out Two model implementation files hardcode trust_remote_code=True for sub-component loads, so a malicious model repository runs Python even when the user disabled remote code.
- PickleScan's profile.run blocklist mismatch allows exec() bypass A pickle calling the module-level profile run function reaches exec() because the scanner blocklist only matches the class-qualified names.
- Unauthorized npm publish of cline@2.3.0 with modified postinstall script A compromised publish token pushed a package whose postinstall script globally installs an unrelated package on user machines.
- NLTK has a Zip Slip Vulnerability Extracting a downloaded NLTK package without path checks lets a crafted archive write files outside the target, including Python files that run on import.
- Picklescan (scan_pytorch) Bypass via dynamic eval MAGIC_NUMBER A pickle payload calls eval through __reduce__ with a magic-number value the scanner's opcode check misses but the real torch loader still reads.
- picklescan missing detection by simple obfuscation of a `builtins.eval` call A pickle payload hides a builtins eval call behind getattr, so the scanner does not flag it and the code runs when the file is loaded.
- vLLM affected by RCE via auto_map dynamic module loading during model initialization A model repository's auto_map entry makes vLLM import attacker Python during model resolution, even with trust_remote_code disabled.
- Picklescan is vulnerable to RCE via missing detection when calling built-in python _operator.attrgetter Picklescan does not flag _operator.attrgetter gadgets, so a hand-built pickle reaching __import__ runs shell commands when loaded.
- Picklescan is vulnerable to RCE through missing detection when calling numpy.f2py.crackfortran._eval_length A pickle using a numpy f2py helper as its reduce callable executes code on load, and picklescan fails to flag this gadget as dangerous.
- Picklescan is vulnerable to RCE via missing detection when calling built-in python _operator.methodcaller A pickle using the _operator.methodcaller reducer is not flagged by the scanner, so loading it still runs attacker-chosen commands.
- Picklescan is vulnerable to RCE via missing detection when calling numpy.f2py.crackfortran.getlincoef
- Picklescan is vulnerable to RCE through missing detection when calling numpy.f2py.crackfortran.myeval A pickle payload calling a numpy helper evades picklescan's blocklist, so a file reported safe still runs code when loaded.
- Picklescan does not block ctypes Picklescan's denylist omits ctypes, so a pickle that calls ctypes.WinDLL and foreign functions evades detection and runs native code on load.
- Picklescan has Incomplete List of Disallowed Inputs The pickle scanner's deny-list misses pydoc.locate and operator.methodcaller, so a crafted pickle chaining them to call os.system passes the scan.
- Picklescan is vulnerable to RCE through missing detection when calling built-in python operator.methodcaller
- vLLM vulnerable to remote code execution via transformers_utils/get_config Loading a model config whose auto_map points to another repository imports and runs that repository's Python even when remote code is disabled.
- Picklescan is Vulnerable to Unsafe Globals Check Bypass through Subclass Imports Pickles referencing subclasses of dangerous asyncio classes evade picklescan's exact module-name check, so their embedded payloads load and execute.
- Picklescan is missing detection when calling built-in python cProfile.run A pickle payload calling cProfile.run executes arbitrary code on load, and the picklescan detector does not flag it.
- Picklescan is missing detection when calling pytorch function torch.utils.bottleneck.__main__.run_autograd_prof A crafted pickle calls a torch profiling helper that runs arbitrary code, and the scanner does not flag that function, so loading the file executes it.
- Picklescan has a missing detection when calling built-in python trace.Trace.run A pickle that calls trace.Trace.run to run a shell command is not flagged by the scanner, so loading it executes the code.
- Picklescan has a missing detection when calling built-in python idlelib.calltip.Calltip A pickle payload calls idlelib's Calltip.fetch_tip, which evaluates arbitrary expressions, and picklescan does not flag it, so unpickling runs attacker code.
- Picklescan is missing detection when calling built-in Python cProfile.runctx Picklescan does not flag cProfile.runctx, so a pickle that calls it to run arbitrary code passes the scan and executes on load.
- Picklescan has a missing detection when calling built-in python code.InteractiveInterpreter A malicious pickle calls the interactive interpreter's runcode method, which the scanner does not flag, so loading the file still runs attacker code.
- Picklescan has a missing detection when calling built-in python lib2to3.pgen2.grammar.Grammar.loads A pickle that calls lib2to3's Grammar.loads to run embedded code is not flagged by picklescan, so loading it executes the attacker's payload.
- Picklescan is missing detection when calling built-in python doctest.debug_script A pickle payload invokes doctest's debug_script to run embedded code, and the scanner does not flag that call.
- Picklescan missing detection when calling pytorch function torch._dynamo.guards.GuardBuilder.get A PyTorch dynamo helper is missing from the scanner's list, so a pickle that calls it to run shell commands is reported as safe.
- Picklescan missing detection when calling pytorch function torch.fx.experimental.symbolic_shapes.ShapeEnv.evaluate_guards_expression A pickle payload calling a PyTorch symbolic shapes function evades picklescan's detection yet executes arbitrary code when loaded.
- Picklescan missing detection when calling pytorch function torch.utils.collect_env.run A pickle that calls PyTorch's collect_env run helper to execute a shell command is not detected by picklescan, so loading it runs the command.
- Skops may allow MethodNode to access unexpected object fields through dot notation, leading to arbitrary code execution at load time Chained dot-notation access in the skops loader reaches unrestricted object attributes, so a crafted model file runs code during loading.
- PyTorch: `torch.load` with `weights_only=True` leads to remote code execution A crafted checkpoint abuses a deserialisation path that the weights-only loader still allows, so loading the file runs code.
- BentoML's runner server Vulnerable to Remote Code Execution (RCE) via Insecure Deserialization Crafted POST requests make the BentoML runner server unpickle attacker-supplied data, which runs arbitrary code on the server.
- Arbitrary Code Execution via Crafted Keras Config for Model Loading A malicious .keras archive with an edited config.json names arbitrary modules and functions that run during load_model, even with safe mode on.