⚠️ Avvertenza

Questo repository è destinato esclusivamente a ricerca sulla sicurezza autorizzata, test di penetrazione e scopi didattici. Non utilizzare le tecniche qui descritte contro sistemi senza autorizzazione esplicita.

⚡ MCPJam → Root

Dalla RCE di MCPJam Inspector a root — CVE-2026-23744, divulgazione del token di JupyterLab, esecuzione del kernel ed escalation dei privilegi di OPSMCP.

📖 Panoramica

Questo repository documenta una catena di attacco Linux completa, da un'istanza esposta di MCPJam Inspector fino all'accesso di livello root.

La catena combina vulnerabilità presenti negli strumenti di sviluppo, nei servizi locali, nella gestione delle credenziali e nell'autorizzazione delle applicazioni:

MCPJam Inspector
       │  CVE-2026-23744
       ▼
     RCE
       │
       ▼
JupyterLab Token
       │
       ▼
Jupyter Kernel
       │
       ▼
     User
       │
       ▼
  OPSMCP API
       │
       ▼
Hidden Admin Tool
       │
       ▼
Root Credential
       │
       ▼
     root

[!WARNING] Questo repository è destinato esclusivamente a ricerca sulla sicurezza autorizzata, test di penetrazione e scopi didattici. Gli indirizzi target, le credenziali, i token e gli altri valori specifici dell'ambiente presenti in questo documento sono oscurati o sostituiti con segnaposto di laboratorio.

📑 Indice

• 🎯 Percorso di attacco
• 🔎 Enumerazione
• 💥 CVE-2026-23744 — RCE di MCPJam Inspector
• 🕵️ Enumerazione interna
• 🔐 Divulgazione del token di JupyterLab
• 🧠 Esecuzione del kernel di JupyterLab
• 📂 Codice sorgente di OPSMCP
• 🚨 Funzione amministrativa nascosta
• 🔑 Divulgazione delle credenziali di root
• 👑 Root
• 🗺️ Catena di attacco completa
• 🧩 Riepilogo delle vulnerabilità
• 🛡️ Mitigazione
• 🔍 Rilevamento
• 💡 Punti chiave
• 📚 Riferimenti

🎯 Percorso di attacco

🔎 Enumerazione

La ricognizione iniziale si concentra sull'identificazione dei servizi esposti esternamente.

nmap -sC -sV -oN nmap_initial.txt TARGET

È quindi possibile eseguire una scansione TCP completa:

nmap -p- --min-rate 5000 -oN nmap_full.txt TARGET

Servizi esterni rilevanti:

Servizi in ascolto solo su localhost:

L'istanza di MCPJam Inspector accessibile esternamente sulla porta 6274 diventa il punto di ingresso iniziale.

💥 CVE-2026-23744 — RCE di MCPJam Inspector

L'istanza esposta di MCPJam Inspector è affetta da CVE-2026-23744.

MCPJam Inspector è progettato principalmente come interfaccia di sviluppo e test per i server MCP. La vulnerabilità diventa particolarmente pericolosa quando questa interfaccia è esposta a una rete non fidata: un flusso di configurazione vulnerabile consente a dati controllati dall'attaccante di raggiungere un percorso di esecuzione dei comandi.

Remote Request
      │
      ▼
MCP Server Configuration
      │
      ▼
Command Execution
      │
      ▼
Initial Shell

La vulnerabilità interessa le versioni di MCPJam Inspector fino alla 1.4.2 inclusa. Per test autorizzati, è possibile utilizzare un proof of concept pubblico per validare la vulnerabilità nell'ambiente target.

Dopo lo sfruttamento riuscito, conferma il contesto di esecuzione:

id
whoami
hostname

🕵️ Enumerazione interna

Una volta ottenuto il primo accesso, i servizi locali diventano visibili.

ss -tlnp
ps aux | grep -E 'jupyter|python|node'

                    Network
                       │
                       ▼
              MCPJam Inspector
                   :6274
                       │
                       ▼
                 Initial RCE
                       │
             ┌─────────┴─────────┐
             ▼                   ▼
        JupyterLab             OPSMCP
        :8888/local            :5000/local
             │                   │
             ▼                   ▼
            User                root

La differenza di privilegi tra le due applicazioni interne è particolarmente interessante.

🔐 Divulgazione del token di JupyterLab

Il processo JupyterLab è stato avviato con il token di autenticazione direttamente nella riga di comando:

--ServerApp.token=<JUPYTER_TOKEN>

La riga di comando può essere ispezionata tramite:

ps aux | grep jupyter
# or
cat /proc/<PID>/cmdline

Questo dimostra un problema comune di gestione dei segreti:

Secret → Command-line argument → Process metadata → Local credential disclosure

Il token recuperato fornisce accesso all'API Jupyter locale.

🧠 Esecuzione del kernel di JupyterLab

Jupyter espone un'API REST per la gestione dei kernel. Dopo l'autenticazione con il token recuperato, è possibile creare un kernel tramite:

POST /api/kernels

La risposta contiene un UUID del kernel. I kernel di Jupyter comunicano tramite WebSocket:

/api/kernels/<KERNEL_ID>/channels

Il protocollo di messaggistica di Jupyter utilizza un messaggio execute_request per eseguire codice Python:

{
  "header": { "msg_type": "execute_request" },
  "content": { "code": "<AUTHORIZED_LAB_CODE>" }
}

Questo consente l'esecuzione di Python sotto l'identità del servizio Jupyter — in questo ambiente, il kernel viene eseguito come User.

MCPJam RCE → JupyterLab → User

📂 Codice sorgente di OPSMCP

Con una shell utente disponibile, il passo successivo consiste nell'esaminare le applicazioni installate localmente. L'applicazione OPSMCP si trova in:

/opt/opsmcp/

L'esame del codice sorgente rivela una credenziale API incorporata:

VALID_API_KEY = "<REDACTED_OPSMCP_API_KEY>"

L'applicazione mantiene inoltre due raccolte di strumenti:

Strumenti visibili

• ops.system_status
• ops.list_services
• ops.check_disk
• ops.view_logs

Strumenti nascosti

• ops._admin_dump
• ops._debug_mode

Le funzioni amministrative sono particolarmente interessanti perché non vengono restituite tramite la normale enumerazione degli strumenti.

Non documentato non significa non accessibile.

Il backend registra comunque gli strumenti nascosti e accetta i loro nomi tramite il meccanismo generico di esecuzione degli strumenti.

🚨 Funzione amministrativa nascosta

L'applicazione autentica le richieste utilizzando una chiave API:

X-API-Key: <OPSMCP_API_KEY>

Una volta autenticato, l'endpoint di esecuzione degli strumenti verifica solo se la funzione richiesta esiste — non se al chiamante è consentito eseguirla.

Cosa accade:

API Key → Authenticated → Tool exists? → Execute

Cosa dovrebbe accadere:

API Key → Authenticated → Permission check → Allowed → Execute
                                            └ Denied  → 403

La funzione amministrativa nascosta può accedere a risorse sensibili di proprietà di root.

🔑 Divulgazione delle credenziali di root

Lo strumento amministrativo accetta un target che descrive le informazioni richieste. Una delle risorse supportate è la chiave SSH di root:

{
  "name": "ops._admin_dump",
  "arguments": {
    "target": "ssh_keys",
    "confirm": true
  }
}

L'applicazione legge quindi la chiave privata SSH di proprietà di root, cosa possibile perché OPSMCP viene eseguito come root e può leggere /root/*. L'applicazione diventa quindi una primitiva di divulgazione delle credenziali.

👑 Root

Dopo aver recuperato la credenziale SSH del laboratorio autorizzato, salvala con permessi restrittivi:

chmod 600 <ROOT_KEY>

Verifica il contesto di autenticazione risultante:

whoami
id

Livello di privilegio finale: root 🎉

🗺️ Catena di attacco completa

┌──────────────────────────────┐
│       MCPJam Inspector       │
│          TCP/6274            │
└──────────────┬───────────────┘
               │ CVE-2026-23744
               ▼
┌──────────────────────────────┐
│          Initial RCE         │
└──────────────┬───────────────┘
               ▼
┌──────────────────────────────┐
│          JupyterLab          │
│        127.0.0.1:8888        │
└──────────────┬───────────────┘
               │ Token disclosure
               ▼
┌──────────────────────────────┐
│       Jupyter Kernel         │
│        WebSocket RCE         │
└──────────────┬───────────────┘
               ▼
             User
               │ Source review
               ▼
┌──────────────────────────────┐
│           OPSMCP             │
│        127.0.0.1:5000        │
│             root             │
└──────────────┬───────────────┘
               │ API key + hidden tool
               ▼
┌──────────────────────────────┐
│    Root Credential Leak      │
└──────────────┬───────────────┘
               ▼
              root

🧩 Riepilogo delle vulnerabilità

🛡️ Mitigazione

🔍 Rilevamento

💡 Punti chiave

01 — Gli strumenti per sviluppatori sono superficie di attacco Gli strumenti progettati per lo sviluppo locale possono diventare vulnerabilità critiche quando esposti a reti non fidate.

02 — I token di Jupyter sono credenziali potenti L'accesso a un token di Jupyter può fornire molto più dell'accesso all'interfaccia: le API dei kernel possono consentire l'esecuzione arbitraria di codice.

03 — Nascosto non significa sicuro Un endpoint non documentato non è un meccanismo di autorizzazione.

04 — Il codice sorgente è prezioso post-exploitation Il codice sorgente dell'applicazione può rivelare immediatamente meccanismi di autenticazione, segreti, funzionalità nascoste e confini di privilegio.

05 — Il principio del minimo privilegio può spezzare le catene di attacco Se OPSMCP fosse stato eseguito con un account di servizio senza privilegi, l'impatto finale sarebbe stato significativamente ridotto.

📚 Riferimenti

• CVE-2026-23744 — Esecuzione remota di codice in MCPJam Inspector
• Documentazione di JupyterLab — Architettura di kernel e API
• OWASP — Least Privilege
• OWASP — Secrets Management