Browse / Unsafe Model Loading and Supply Chain
Unsafe Model Loading and Supply Chain
Malicious model files, pickle deserialisation, poisoned packages and artifacts. 280 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
- Real-world incidents 6
- 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
- ONNX: Out-of-bounds read in ConvTranspose shape inference via undersized weight rank A crafted model whose weight tensor has fewer than three dimensions triggers an out-of-bounds read during shape inference, crashing the process.
- ONNX: Denial of service via unchecked expansion of packed sub-byte tensors in ONNX Python APIs A tiny malicious model declares a huge dimension for packed sub-byte tensors, and the helpers allocate memory for it before checking the payload size.
- vLLM: Public multimodal SHM handle forgery reaches worker-side `pickle.loads()` with insecure serialization disabled Forged shared-memory handles in vLLM's multimodal cache reach pickle.loads in the worker, and this works without the insecure-serialisation opt-in.
- 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.
- NLTK: Allowlisted pickle loaders still permit code execution in current source Allowlisted pickle loaders trust whole module namespaces, so a crafted pickle can call dangerous helpers such as subprocess-spawning functions during unpickling.
- MLFLOW_ALLOW_PICKLE_DESERIALIZATION=False safety control bypassed by mlflow.statsmodels flavor — RCE via crafted model artifact The statsmodels loader skips the pickle deserialisation guard, so a crafted model artifact runs code when loaded even with pickle disabled.
- Hugging Face Transformers downloads custom generation code before trust consent Remote custom generation code is written into the local module cache before the trust prompt is shown, so declined code still persists on disk.
- 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.
- Accelerate path traversal and denial of service via sharded checkpoint weight_map entries A sharded checkpoint index with traversal or absolute paths, or named pipes, makes the loader read arbitrary files or hang while loading weights.
- Feast vulnerable to arbitrary code execution via unsafe deserialization of dill-serialized UDFs Stored registry functions serialised with dill are deserialised by the server, so a malicious function placed in the registry runs code on the feature server.
- Keras model loading is vulnerable to denial of service through HDF5 shape bombs A specially crafted .keras archive declares oversized HDF5 datasets, so loading it allocates unbounded memory and the process is killed.
- NLTK downloader allows cross-package resource and model poisoning The downloader extracts packages into shared directories and verifies integrity only afterwards, so one package can overwrite another's corpora and models.
- Keras: HDF5 links can disclose local file contents A malicious model file with HDF5 external links makes Keras load and expose local files through functions that skip its link-safety helpers.
- Transformers save_pretrained path traversal allows arbitrary file writes through chat template names A malicious Hub tokenizer config uses chat template keys as filenames, so saving it writes attacker content outside the intended directory.
- 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.
- Keras: TorchModuleWrapper can deserialize unsafe PyTorch pickle data The TorchModuleWrapper config loader calls torch.load with unrestricted unpickling unless an ambient safe-mode flag is set, so untrusted configs run code.
- PyTorch Lightning allows arbitrary code execution through checkpoint _instantiator hyperparameters A crafted checkpoint supplies a module name in hyperparameters that is imported during loading, bypassing the weights_only protection.
- ONNX has Null Pointer Dereference in Upsample Version Converter Adapter (Zero Inputs) A crafted ONNX model with an Upsample node that has no inputs makes the version converter dereference an invalid pointer and crash.
- 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.
- Keras: HDF5 virtual datasets can disclose local files A malicious .keras or .h5 model file with virtual datasets pointing at local HDF5 files makes Keras read those files when the model is loaded, because the earlier fix missed this check.
- LangGraph Checkpoint: Unsafe JSON deserialization in checkpoint loading Tampered checkpoint bytes in a persistent store can make the JSON serializer rebuild arbitrary Python objects when a checkpoint is loaded.
- Keras: DiskIOStore permits path traversal through crafted layer names A crafted layer name containing parent-directory sequences escapes the temporary save directory when a model is saved or loaded, since only slashes are filtered.
- 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.
- MLFlow Creates a Temporary File With Insecure Permissions Model artifact temp directories are created world- or group-writable, so local users can replace cloudpickle files that are later loaded and executed.
- SGLang: Unauthenticated RCE via --enable-custom-logit-processor A custom logit processor sent to the server is deserialised with dill.loads, so an unauthenticated request can run Python code when the option is enabled.
- LangSmith SDK: Public prompt pull deserializes untrusted manifests without trust boundary warning Pulling a public prompt by owner/name deserialises its manifest as trusted configuration, so attacker-authored constructor arguments and environment-backed secret references can run or leak.
- 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.
- Ludwig framework is vulnerable to insecure deserialization through its predict() method. A crafted pickle file supplied as a dataset path is loaded with pandas.read_pickle without validation, so embedded Python objects run during prediction.
- Ludwig framework is vulnerable to insecure deserialization in its model serving component The model server loads weight files with unrestricted torch.load, so a crafted checkpoint executes arbitrary Python objects when served.
- PyTorch Lightning load_from_checkpoint has an insecure checkpoint deserialization load_from_checkpoint calls torch.load without weights_only, so a malicious checkpoint runs pickle-based code when it is loaded.