Browse / Unsafe Model Loading and Supply Chain
Unsafe Model Loading and Supply Chain
Malicious model files, pickle deserialisation, poisoned packages and artifacts. 274 records. Reference: OWASP LLM03 · ATLAS AML.T0010.
- Code and command execution 98
- Unsafe deserialisation 77
- Denial of service 39
- Path traversal and file access 20
- Memory corruption 18
- Data exfiltration 5
- Publish Poisoned AI Artifacts: Models 5
- Other weaknesses 3
- Supply Chain Compromise: Software 3
- Information exposure 2
- Supply Chain Compromise: Data Repository 2
- Cross-site scripting 1
- Publish Poisoned AI Artifacts: AI Agent Tools 1
- 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.
- LangChain vulnerable to unsafe deserialization of attacker-controlled objects through overly broad `load()` allowlists Overly permissive load settings revive attacker-supplied serialized constructor dictionaries in runtime paths, instantiating classes with attacker-chosen arguments.
- 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.
- Compromise of PyTorch Lightning PyPi Package Versions Published package versions were compromised with code that harvests credentials, so installing them exposes secrets.
- Keras vulnerable to DoS via Malicious .keras Model (HDF5 Shape Bomb Causes Petabyte Allocation in KerasFileEditor) A small .keras archive declaring a huge HDF5 dataset shape makes Keras allocate enormous memory when it loads the weights.
- Ollama contains a heap out-of-bounds read vulnerability in the GGUF model loader A crafted GGUF file declares tensor offsets beyond its real length, so quantisation reads past a heap buffer and leaks adjacent memory such as secrets and chats.
- SGLang has an Improper Input Validation/Injection Issue A remotely supplied model or tokenizer reference causes unsafe deserialisation inside the transformers helper that loads the tokenizer.
- mem0ai mem0 has an Improper Input Validation Issue The FAISS vector store module calls pickle load on stored data, so a crafted file executes code when deserialised.
- 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.
- HuggingFace Transformers allows for arbitrary code execution in the `Trainer` class A crafted RNG state checkpoint executes code when the Trainer loads it, because torch.load runs without the weights-only restriction.
- 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.
- ONNX: Malicious ONNX models can crash servers by exploiting unprotected object settings. A malicious model file sets arbitrary attributes on external data metadata objects, so oversized lengths exhaust memory and dunder attributes corrupt objects.
- ONNX: Arbitrary File Read via ExternalData Hardlink Bypass in ONNX load A model's external data reference points to a hardlink, which passes the symlink-only check, so loading the model can read arbitrary local files.
- ONNX: External Data Symlink Traversal The external data check follows symlinks, so a model whose external data path points through a link outside its directory gets an arbitrary file read.
- onnx Vulnerable to Path Traversal via Symlink A symlink check in the ONNX checker uses a function that follows links, so external data references can point at and read arbitrary files outside the model directory.
- 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.
- Two LiteLLM versions published containing credential harvesting malware Malicious releases were published to PyPI containing code that harvests credentials and files and sends them to a remote server.
- Arbitrary file write via tar traversal in mlflow Extracting a crafted pyfunc model archive with unvalidated tar entry paths writes files outside the target directory.
- 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.
- SGLang's encoder parallel disaggregation system is vulnerable to unauthenticated remote code execution through the disaggregation module Network-reachable disaggregation handlers pass untrusted bytes to pickle.loads without authentication, so a remote sender runs code on the server.
- LangGraph checkpoint loading has unsafe msgpack deserialization Persisted checkpoints are decoded with msgpack that can rebuild Python objects, so someone who can write to the store can get code run on load.
- BentoML Vulnerable to Arbitrary File Write via Symlink Path Traversal in Tar Extraction Tar extraction validates symlink paths but not their targets, so a crafted model archive can write files outside the destination through a symlink.
- 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 has multiple stdlib modules with direct RCE not in blocklist The scanner's blocklist omits several standard library modules that can run shell commands, so pickles using them are reported as clean.
- 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.
- LangGraph: BaseCache Deserialization of Untrusted Data may lead to Remote Code Execution When msgpack fails, LangGraph's default cache serializer falls back to pickle.loads, so anyone able to write the cache backend can run code.
- 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.
- Keras has a Local File Disclosure via HDF5 External Storage During Keras Weight Loading A malicious HDF5 weights file uses external storage links that load_weights follows, so contents of arbitrary host files are read into model tensors, bypassing safe mode.
- 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.
- picklescan vulnerable to arbitrary file create using logging.FileHandler Pickle payloads that instantiate logging.FileHandler slip past the scanner's blocklist and create empty files at attacker-chosen paths.
- PyTorch Vulnerable to Remote Code Execution via Untrusted Checkpoint Files A crafted .pth checkpoint passes the weights-only unpickler despite invalid opcodes and storage sizes, corrupting heap memory during torch.load.
- Supply Chain Compromise via Poisoned ClawdBot Skill
- 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 has Arbitrary file read using `io.FileIO` A crafted pickle chains file-reading and HTTP-posting callables to send local file contents to an external server, evading the scanner's execution-focused blocklist.
- 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 A pickle that calls a NumPy F2PY helper to run Python code evades Picklescan's detection, so loading the scanned-as-safe file executes 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.
- Picklescan is vulnerable to RCE via missing detection when calling numpy.f2py.crackfortran.param_eval A pickle payload calls a numpy helper that the scanner does not flag, so scanning passes and loading the file executes attacker-supplied code.
- Picklescan Bypasses Unsafe Globals Check using pty.spawn A pickle payload calling pty.spawn evades the scanner because that function is missing from its unsafe globals list, enabling code execution when loaded.