Browse / Unsafe Model Loading and Supply Chain / Code and command execution
Code and command execution
98 records in Unsafe Model Loading and Supply Chain.
- vLLM: Request-controlled mm_processor_kwargs.code_revision allows remote code execution A client request field selects another repository revision for processor code, so Transformers imports attacker-chosen Python when trust_remote_code is enabled.
- Claude Code: Plugin Hash Pin Bypass Allows Bypass of Hash Pinning A git checkout of a pinned commit did not confirm the resulting HEAD, so a SHA-named attacker branch could replace the reviewed plugin code.
- 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.
- NLTK: Unsafe Pickle Deserialization in TransitionParser Allows Remote Code Execution NLTK TransitionParser unpickles model files without restriction, so a malicious model runs code when it is loaded.
- PraisonAI workflow include bypasses tools.py autoload opt-in and executes included recipe code Including a local recipe in a workflow runs its tools.py module code even when the autoload opt-in is off, getting around earlier hardening.
- NLTK AllowlistUnpickler dotted-name validation bypass allows remote code execution A malicious transition-parser model uses dotted-name attribute traversal to reach callables outside the unpickler allowlist, running commands when the model loads.
- sentence-transformers local model loading bypasses trust_remote_code and executes custom Python When the model path exists locally, the trust_remote_code gate is skipped, so Python files in the model directory are imported even though remote code is disabled.
- Ray: Arbitrary code execution via ray.data.read_webdataset default decoder: pickle.loads(value) and torch.load(weights_only=False) A crafted WebDataset tar file makes Ray's default decoder run pickle.loads and torch.load on attacker bytes during a standard read, executing code.
- 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.
- Keras: Lambda deserialization can bypass safe mode and execute code A model config containing a Lambda layer with marshalled bytecode runs when deserialised, because the safe-mode guard fails when the flag is left unset.
- vLLM: Security Check Bypass via assert Statement in Activation Function Loading Allows Arbitrary Code Execution The only check on which activation function a model config may load is an assert, which Python strips in optimised mode, so a malicious config runs arbitrary code.
- 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.
- huggingface/transformers: Arbitrary Code Execution During Model Initialization in the LightGlue Model Loading Path A model config can set trust_remote_code internally to true, so loading with it disabled still imports attacker-supplied Python modules.
- 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.
- Amazon SageMaker Python SDK is missing integrity verification in its Triton inference handler The Triton handler unpickles model artifacts without integrity checks, so anyone who can write to the artifact path can run code when the model loads.
- 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.
- Malicious code in guardrails-ai 0.10.1 (supply chain compromise) A trojanised guardrails-ai release was published to PyPI, so installing that version runs attacker code on the host and can expose its credentials.
- ModelScope is vulnerable to arbitrary code injection via a crafted module A module path named in a model configuration file is imported without checks, so loading a crafted config runs attacker-chosen code.
- 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.
- Malicious dropper in mistralai 2.4.6 PyPI package A published package version runs a downloader on import that fetches and launches a remote executable on Linux hosts.
- Guardrails AI contains a code injection vulnerability in its Hub package installation mechanism A malicious validator package's manifest names a post-install script path that is executed unvalidated during guardrails hub install, running attacker code.
- Dockerfile command injection via envs[*].name in bentofile.yaml (sibling fix-bypass of CVE-2026-33744 and CVE-2026-35043) A malicious bentofile env name with embedded newlines produces unquoted Dockerfile RUN lines that execute during container builds, bypassing earlier quoting fixes.
- 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 Ray passes the metadata of a Parquet extension type to cloudpickle.loads, so opening a crafted Parquet file runs code during schema parsing.
- 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.
- PraisonAI Vulnerable Untrusted Remote Template Code Execution Remote template files are downloaded and their tools.py is executed automatically with no integrity check or user confirmation, so a malicious template runs code.
- PraisonAI has critical RCE via `type: job` workflow YAML A workflow YAML's run and script steps are executed directly on the host, so a malicious file runs arbitrary commands when launched.
- BentoML: SSTI via Unsandboxed Jinja2 in Dockerfile Generation A malicious bento archive supplies a Jinja2 Dockerfile template that is rendered in an unsandboxed environment, executing Python on the builder's host.
- MLflow Command Injection vulnerability Dependency entries in a model artifact's python_env.yaml are inserted unescaped into a shell command during local serving setup, so attacker commands run on deployment.
- 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.
- ONNX Untrusted Model Repository Warnings Suppressed by silent=True in onnx.hub.load() — Silent Supply-Chain Attack Silent mode on the hub loader skips the untrusted-repository prompt, so models from any repo load unnoticed and the checksum comes from the same attacker-controlled repo.
- SGLangs `replay_request_dump.py` contains an insecure pickle.load() without validation and proper deserialization A replay debugging script calls pickle.load on a user-supplied file, so a malicious pickle runs code when the script is executed.
- 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.
- PickleScan's pkgutil.resolve_name has a universal blocklist bypass A pickle calls pkgutil.resolve_name with a module:attribute string to obtain a blocked function such as os.system, so the dangerous name never appears in the opcodes.
- 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 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.