CVE-2026-28496-Lab — Docker-basiertes Labor zur Reproduktion und Validierung von CVE-2026-28496, einer Server-seitigen Template-Injection-Schwachstelle in der Twig-Wiedergabe von FOSSBilling, mit Zielen für den Vergleich von anfälligen und gepatchten Versionen. | Kitploit

Diese Laborumgebung validiert das anfällige im Vergleich zum gepatchten HTTP-Verhalten mittels FOSSBilling 0.7.2 und FOSSBilling 0.8.0.

Die Laborumgebung ist absichtlich auf lokale Docker-Dienste beschränkt. Sie richtet sich nicht gegen externe Systeme und enthält keine Webshells, Malware, Persistenz, externe Callbacks, Datenbank-Dumps oder zerstörerische Payloads.

## Verifizierte Fakten

| Behauptung                                                                               | Nachweis                                                                                                           | Wie im Labor zu überprüfen                                                              |
| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------- |
| CVE-2026-28496 betrifft FOSSBilling-Versionen vor 0.8.0.                                 | Öffentliche CVE- und Advisory-Metadaten identifizieren FOSSBilling vor 0.8.0 als von Twig SSTI betroffen.          | Lesen Sie den Referenzbereich und vergleichen Sie die anfälligen und gepatchten Zielversionen.|
| FOSSBilling 0.7.2 wird als anfälliges Vergleichsziel verwendet.                         | Der anfällige Dienst wird aus dem offiziellen `fossbilling/fossbilling:0.7.2` Docker-Image erstellt.               | Überprüfen Sie `vuln/Dockerfile` und führen Sie `docker compose ps -a` aus.             |
| FOSSBilling 0.8.0 wird als gepatchtes Vergleichsziel verwendet.                         | Der gepatchte Dienst wird aus dem offiziellen `fossbilling/fossbilling:0.8.0` Docker-Image erstellt.               | Überprüfen Sie `patched/Dockerfile` und führen Sie `docker compose ps -a` aus.           |
| Der anfällige HTTP-Pfad ist `/api/system/system/string_render`.                         | Das anfällige Ziel gibt JSON mit `result: "49"` für `_tpl={{ 7*7 }}` zurück.                                       | Führen Sie `python3 poc/poc.py --url http://localhost:8081` aus.                        |
| Das gepatchte Ziel zeigt nicht dasselbe HTTP-Verhalten.                                 | Das gepatchte Ziel gibt `Unknown API call system/system/string_render` zurück.                                     | Führen Sie `python3 poc/poc.py --url http://localhost:8082` aus.                        |
| Der Proof-of-Concept (PoC) ist rein HTTP-basiert.                                       | `poc/poc.py` sendet HTTP-POST-Anfragen und ruft keine Docker-, Docker-Compose-, Shell-Befehle oder Container-APIs auf.| Überprüfen Sie `poc/poc.py`.                                                            |
| Das Labor installiert beide FOSSBilling-Ziele automatisch beim Start von Docker Compose. | Die One-Shot-Installer-Seitencontainer schließen die Einrichtung ab und beenden mit Status 0.                      | Führen Sie `docker compose ps -a` und `docker compose logs installer-vuln installer-patched` aus.|
| Das anfällige Ziel rendert den harmlosen Twig-Ausdruck.                                 | Die HTTP-Antwort von Port 8081 ist `{"result":"49","error":null}`.                                                 | Führen Sie den anfälligen PoC-Befehl aus.                                               |
| Das gepatchte Ziel rendert denselben Ausdruck nicht über den getesteten API-Pfad.       | Die HTTP-Antwort von Port 8082 ist ein JSON-API-Fehler mit Code `879`.                                             | Führen Sie den gepatchten PoC-Befehl aus.                                               |

## Annahmen und Unbekanntes

Dieses Labor verwendet FOSSBilling 0.7.2 als anfälliges Vergleichsziel, da öffentliche Sicherheitsforschung FOSSBilling-Versionen vor 0.8.0 als betroffen identifiziert und 0.7.2 die neueste anfällige Version in der getesteten Kette ist.

Dieses Labor verwendet FOSSBilling 0.8.0 als gepatchtes Vergleichsziel, da öffentliche Advisory-Metadaten 0.8.0 als die gepatchte Version ausweisen.

Dieses Labor konzentriert sich auf das beobachtbare HTTP-Verhalten von:```text
POST /api/system/system/string_render

Das Labor zeigt, dass FOSSBilling 0.7.2 den bereitgestellten Twig-Ausdruck über den HTTP-API-Pfad rendert, während FOSSBilling 0.8.0 denselben API-Aufruf nicht bereitstellt.

Dieses Labor erhebt nicht den Anspruch, jede FOSSBilling-Vorlagen-Rendering-Funktion zu testen. CVE-2026-28496 bezieht sich auch auf andere Twig-Rendering-Kontexte, wie zum Beispiel Vorlagen-Rendering-Funktionen, die innerhalb der Anwendung verfügbar sind.

Dieses Labor demonstriert nicht die vollständige unauthentifizierte Remote-Codeausführungskette. Es validiert das beobachtete unauthentifizierte HTTP-Verhalten im lokalen FOSSBilling 0.7.2-Ziel und vergleicht es mit FOSSBilling 0.8.0. Die vollständige öffentliche Kette beinhaltet zusätzliches API-Autorisierungsverhalten über die hier gezeigte sichere Twig-Ausdrucksvalidierung hinaus.

Das Labor demonstriert nicht:

* Remote-Befehlsausführung,
* Extraktion von Anmeldeinformationen,
* Datenbank-Dumping,
* Installation von Erweiterungen,
* Beliebiges Dateischreiben,
* Persistenz,
* Web-Shell-Upload,
* Externe Rückrufe,
* Angriffe auf Nicht-Lab-Systeme,
* oder Post-Exploitation-Aktivität.

## Zusammenfassung der Ursache

Die Ursache von CVE-2026-28496 ist unsicheres Twig-Vorlagen-Rendering.

FOSSBilling verwendet Twig, um dynamische Vorlagen zu rendern. In anfälligen Versionen kann ein bereitgestellter Vorlagenstring ohne ausreichende Sandbox-Einschränkungen in die Twig-Rendering-Logik übergeben werden.

Das anfällige Verhalten kann wie folgt zusammengefasst werden:```text
Input template string
→ FOSSBilling API receives _tpl
→ System\Api\Admin::string_render() reads _tpl
→ System\Service::renderString() receives the template string
→ Twig creates a template from the supplied string
→ Twig evaluates the expression
→ rendered output is returned in the HTTP response

Das gepatchte Design in FOSSBilling 0.8.0 härtet das anfällige Verhalten. In diesem Labor legt das gepatchte Ziel den getesteten API-Aufruf nicht mehr offen:```json
{"result":null,"error":{"message":"Unknown API call system/system/string_render","code":879}}

## Quellcode-Analyse

Das anfällige HTTP-Verhalten wird durch den Quellcode-Pfad in FOSSBilling 0.7.2 gestützt.

Die API-Methode empfängt `_tpl` aus den Anfragedaten und übergibt es an den System-Service-Renderer.

Relevanter anfälliger Einstiegspunkt:```php
public function string_render($data)
{
    if (!isset($data['_tpl'])) {
        error_log('_tpl parameter not passed');
        return '';
    }

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

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

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

In FOSSBilling 0.7.2 versucht `renderString()`, den übergebenen Wert als Vorlagennamen zu laden. Wenn das fehlschlägt, behandelt es den übergebenen Wert als Vorlagenzeichenfolge und übergibt ihn an `createTemplateFromString()`.

Vereinfachter verwundbarer Ablauf:```php
public function renderString($tpl, $try_render, $vars)
{
    $twig = $this->di['twig'];

    try {
        $template = $twig->load($tpl);
        $parsed = $template->render($vars);
    } catch (\Exception) {
        // $twig->load throws an exception when $tpl is a raw template string
        $parsed = $this->createTemplateFromString($tpl, $try_render, $vars);
    }

    return $parsed;
}

Allerdings ist die Ursache sicherheitskritischer als die Auswertung arithmetischer Ausdrücke. In angreifbaren Rendering-Kontexten können Twig-Templates mit Anwendungsobjekten interagieren, die in der Template-Umgebung vorhanden sind. Öffentliche Forschung beschreibt Ketten mit höherer Auswirkung, bei denen API-Kontextobjekte Zugriff auf Anwendungsinterna wie den Dependency-Injection-Container gewähren können.

Ein Quellcode-Regressionstest bestätigte das tiefere Verhalten:```text
FOSSBilling 0.7.2:
  {{ guest.getDi() }}
  → DI_VISIBLE

FOSSBilling 0.8.0:
  {{ guest.getDi() }}
  → blocked by Twig sandbox policy

Der Sandbox-Renderer erstellt und rendert ein Template, fängt aber Twig-Sandbox-Verstöße ab und wandelt sie in einen kontrollierten Anwendungsfehler um:```php
final class SandboxedStringRenderer
{
    public static function render(
        Environment $twig,
        string $content,
        array $context = [],
        string $name = 'template'
    ): string {
        try {
            return $twig->createTemplate($content)->render($context);
        } catch (SecurityError $e) {
            throw new InformationException(
                '%name% contains disallowed Twig syntax: %error%',
                [
                    '%name%' => $name,
                    '%error%' => $e->getMessage(),
                ]
            );
        }
    }
}

Die sicherheitsrelevante Änderung ist:```text
Before:
  request-controlled template string
  → Twig createTemplate()
  → render without the patched sandbox boundary

After:
  template string rendering
  → SandboxedStringRenderer
  → Twig sandbox policy
  → method/property access denied by default

Dies bietet zwei nützliche Validierungsebenen:```text
HTTP behavior validation:
  0.7.2 renders {{ 7*7 }} through /api/system/system/string_render.
  0.8.0 does not expose the same API behavior.

Source/root-cause validation:
  0.7.2 allows unsafe Twig rendering behavior.
  0.8.0 introduces sandboxed string rendering and blocks method/property access.

## Laborarchitektur

Das Lab betreibt zwei isolierte FOSSBilling-Installationen mit Docker Compose.```text
.
├── docker-compose.yml
├── vuln/
│   └── Dockerfile
├── patched/
│   └── Dockerfile
├── poc/
│   └── poc.py
├── scripts/
│   └── auto-install.sh
├── README.md
└── .gitignore

Dienst	Komponente	Version / Rolle
vuln	FOSSBilling	verwundbare Zielanwendung
patched	FOSSBilling	gepatchte Zielanwendung
vuln-db	MariaDB	Datenbank für verwundbares Ziel
patched-db	MariaDB	Datenbank für gepatchtes Ziel
installer-vuln	curl sidecar	installiert automatisch verwundbares Ziel
installer-patched	curl sidecar	installiert automatisch gepatchtes Ziel

Das Labor verwendet festgelegte FOSSBilling-Versionen:

| Ziel                   | FOSSBilling-Version | Erwartetes Verhalten                                   |
| --------------------- | ------------------: | --------------------------------------------------- |
| http://localhost:8081 |               0.7.2 | rendert `{{ 7*7 }}` über den verwundbaren API-Pfad |
| http://localhost:8082 |               0.8.0 | legt das gleiche verwundbare API-Verhalten nicht offen    |

Die Installer-Seitenwagen laufen automatisch während `docker compose up`. Sie initialisieren beide FOSSBilling-Ziele mit lokalen einmaligen Datenbankanmeldeinformationen und beenden dann.

Das Labor erstellt oder modifiziert die verwundbare API-Route nicht.

Die Route `/api/system/system/string_render` wird von der FOSSBilling-Anwendung im verwundbaren 0.7.2-Ziel nach der Installation bereitgestellt. Das Docker-Labor installiert die Anwendung nur über den normalen Installationsablauf und sendet dann eine HTTP-Anfrage an den vorhandenen Anwendungsendpunkt.

Das gepatchte 0.8.0-Ziel gibt `Unknown API call system/system/string_render` zurück, was bestätigt, dass das getestete Routenverhalten von der Anwendungsversion selbst kommt und nicht von einer laborerstellten Route.

## Voraussetzungen

* Docker Desktop oder Docker Engine
* Docker Compose v2
* Python 3
* Internet Zugriff während des ersten Ziehens des Docker-Images

Es wird kein Python-Paket von Drittanbietern benötigt. Der PoC verwendet nur Module der Python-Standardbibliothek.

## Schnellstart

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

Der PoC ist HTTP-only. Er ruft kein Docker, Docker Compose, Shell-Befehle, WP-CLI oder Container-APIs auf.

## Erwartete Ergebnisse

### Verwundbares Ziel

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

Der wichtige Unterschied ist:```text
FOSSBilling 0.7.2
→ renders {{ 7*7 }}
→ returns 49

FOSSBilling 0.8.0
→ does not render the supplied template through this API path
→ returns an API error

Für eine tiefere Quellcode-Ebene Root-Cause-Validierung ist der Methodenzugriff ein stärkerer Beweis für das zugrunde liegende Problem. Allerdings verwendet der öffentliche PoC in diesem Repository den sichereren arithmetischen Ausdruck, um die Demonstration einer Kette mit hohem Einfluss zu vermeiden.

## Manuelle HTTP-Reproduktion mit curl

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

## Auswirkungen

Eine Server-Side Template Injection in einer Abrechnungs- und Kundenverwaltungsplattform ist sicherheitskritisch, da die Anwendung Kundendaten, Abrechnungsdaten, Server-Anmeldeinformationen, Zahlungskonfigurationen und von Administratoren kontrollierte Automatisierungslogik speichern kann.

Der gezeigte Lab-Payload ist harmlos und wertet lediglich:```twig
{{ 7*7 }}

Empfohlene Überwachungsmaßnahmen:

* Überprüfen Sie die Zugriffsprotokolle des Webservers auf `/api/system/system/string_render`.
* Überprüfen Sie Anfragen, die `_tpl` in JSON-Anforderungskörpern enthalten.
* Überprüfen Sie Anfragen, die Twig-Syntax wie `{{` und `}}` enthalten.
* Überprüfen Sie erfolgreiche API-Antworten, die gerenderte Template-Ausgaben enthalten.
* Überprüfen Sie fehlgeschlagene API-Antworten auf verdächtige Template-Rendering-Versuche.
* Überprüfen Sie Administratoraktivitäten, wenn eine Ausnutzung vermutet wird.
* Überprüfen Sie Änderungen an Konfigurationen von Templates, E-Mails, Massenmailern und Zahlungsadaptern.
* Überprüfen Sie Anwendungsprotokolle auf Template-Rendering-Fehler oder unerwartete API-Aufrufe.

Erkennungsidee mit hohem Signalwert:```text
POST request to /api/system/system/string_render
AND request body contains "_tpl"
AND request body contains "{{"

## Abhilfe- und Patch-Hinweise

Aktualisieren Sie FOSSBilling auf Version 0.8.0 oder neuer.

Aktualisieren Sie in Produktionsumgebungen auf die neueste verfügbare Version, anstatt bei der Labor-Vergleichsversion zu bleiben.

Empfohlene Abhilfemaßnahmen:

* Aktualisieren Sie FOSSBilling auf 0.8.0 oder neuer.
* Bestätigen Sie, dass die installierte Version nicht im betroffenen Bereich liegt.
* Schränken Sie den öffentlichen Zugriff auf administrative API-Pfade nach Möglichkeit ein.
* Überprüfen Sie die Webzugriffslogs auf Anfragen an `/api/system/system/string_render`.
* Überprüfen Sie Vorlagen, E-Mail-Vorlagen, Massenmailer und benutzerdefinierte Zahlungsadapter auf verdächtige Twig-Syntax.
* Rotieren Sie Geheimnisse, wenn eine Ausnutzung vermutet wird.
* Überprüfen Sie Kunden-, Abrechnungs-, Zahlungs- und Serververwaltungsaufzeichnungen auf unbefugten Zugriff.
* Behandeln Sie WAF-Regeln oder Reverse-Proxy-Blöcke als vorübergehende Kontrollen, nicht als Ersatz für ein Upgrade.

Sicherheitstechnische Lehren:

* Rendern Sie keine nicht vertrauenswürdigen Vorlagenzeichenfolgen in einem privilegierten Anwendungskontext.
* Setzen Sie Anwendungsdienstcontainer keinen Vorlagenkontexten aus.
* Verwenden Sie sandboxiertes Template-Rendering für benutzergesteuerte oder administratorgesteuerte Vorlagenfunktionen.
* Verweigern Sie den Zugriff auf Methoden und Eigenschaften, es sei denn, dies ist ausdrücklich erforderlich.
* Halten Sie API-Autorisierungsfehler explizit und schlagen Sie geschlossen fehl.
* Behandeln Sie Template-Rendering-Funktionen als codeausführungsnahe Oberflächen.

## Nützliche Überprüfungsbefehle

Containerstatus überprüfen:```bash
docker compose ps -a

Untersuche den gepatchten Sandbox-Renderer aus dem ausgecheckten Quellbaum:```bash
git checkout 0.8.0

grep -R "SandboxedStringRenderer" -n src/modules src/library | head -30
grep -R "\$methods = \[\]\|\$properties = \[\]" -n src/library/FOSSBilling/Twig

## Sicherheitsgrenzen

Dieses Labor dient ausschließlich der lokalen Sicherheitsforschung und kontrollierten Vorführungen.

Führen Sie den PoC oder manuelle Curl-Anfragen nicht gegen Systeme aus, die Sie nicht besitzen oder für die Sie keine ausdrückliche Genehmigung zum Testen haben.

Verwenden Sie in diesem Labor keine echten Produktionsanmeldedaten, Kundendaten, Zahlungsdaten, API-Schlüssel oder Produktionsgeheimnisse.

Der beabsichtigte Umfang beschränkt sich auf lokale Docker-Dienste wie:```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082

## Referenzen

* CVE-Eintrag: CVE-2026-28496
  https://www.cve.org/CVERecord?id=CVE-2026-28496

* GitHub Advisory: GHSA-57mv-jm88-66jc
  https://github.com/FOSSBilling/FOSSBilling/security/advisories/GHSA-57mv-jm88-66jc

* VulnCheck: FOSSBilling Auth Bypass und Twig SSTI zu nicht authentifiziertem RCE
  https://www.vulncheck.com/blog/fossbilling-auth-bypass-ssti-rce

* FOSSBilling Docker-Dokumentation
  https://docs.fossbilling.org/getting-started/docker/

* FOSSBilling GitHub-Repository
  https://github.com/FOSSBilling/FOSSBilling

* FOSSBilling Docker-Image
  https://hub.docker.com/r/fossbilling/fossbilling

* Twig-Dokumentation: Sandbox-Erweiterung
  https://twig.symfony.com/doc/3.x/sandbox.html

CVE-2026-28496-Lab

Beliebteste

Zusammenfassung des Quell-Patches

Wie die Validierung funktioniert

Erkennung und Überwachung

Aufräumen

vuln	0.7.2	Verwundbares Vergleichsziel	http://localhost:8081
patched	0.8.0	Gepatchtes Vergleichsziel	http://localhost:8082