CVE-2026-28496-Lab — Laboratório baseado em Docker para reproduzir e validar CVE-2026-28496, uma vulnerabilidade de Server-Side Template Injection no renderizador Twig do FOSSBilling, com alvos de comparação vulneráveis e corrigidos. | Kitploit

Este laboratório valida o comportamento HTTP vulnerável versus corrigido usando FOSSBilling 0.7.2 e FOSSBilling 0.8.0.

O laboratório é intencionalmente limitado a serviços Docker locais. Não visa sistemas externos e não inclui web shells, malware, persistência, callbacks externos, dumping de banco de dados ou cargas destrutivas.

## Fatos Verificados

| Alegação                                                                               | Evidência                                                                                                           | Como verificar neste laboratório                                                              |
| ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------- |
| CVE-2026-28496 afeta versões do FOSSBilling anteriores a 0.8.0.                         | O CVE público e os metadados de aviso identificam o FOSSBilling anterior a 0.8.0 como afetado por SSTI do Twig.                     | Revise a seção de Referências e compare as versões vulnerável e corrigida do alvo.  |
| O FOSSBilling 0.7.2 é usado como alvo vulnerável de comparação.                      | O serviço vulnerável é construído a partir da imagem Docker oficial `fossbilling/fossbilling:0.7.2`.                    | Inspecione `vuln/Dockerfile` e execute `docker compose ps -a`.                              |
| O FOSSBilling 0.8.0 é usado como alvo corrigido de comparação.                         | O serviço corrigido é construído a partir da imagem Docker oficial `fossbilling/fossbilling:0.8.0`.                       | Inspecione `patched/Dockerfile` e execute `docker compose ps -a`.                           |
| O caminho HTTP vulnerável é `/api/system/system/string_render`.                     | O alvo vulnerável retorna JSON com `result: "49"` para `_tpl={{ 7*7 }}`.                                       | Execute `python3 poc/poc.py --url http://localhost:8081`.                                  |
| O alvo corrigido não expõe o mesmo comportamento HTTP.                          | O alvo corrigido retorna `Unknown API call system/system/string_render`.                                         | Execute `python3 poc/poc.py --url http://localhost:8082`.                                  |
| O PoC é exclusivamente HTTP.                                                               | `poc/poc.py` envia requisições HTTP POST e não chama Docker, Docker Compose, comandos de shell ou APIs de contêiner. | Inspecione `poc/poc.py`.                                                                  |
| O laboratório instala automaticamente ambos os alvos FOSSBilling durante a inicialização do Docker Compose.       | Os contêineres sidecar de instalação única completam a configuração e saem com status 0.                                   | Execute `docker compose ps -a` e `docker compose logs installer-vuln installer-patched`. |
| O alvo vulnerável renderiza a expressão Twig inofensiva.                         | A resposta HTTP da porta 8081 é `{"result":"49","error":null}`.                                                | Execute o comando PoC vulnerável.                                                        |
| O alvo corrigido não renderiza a mesma expressão através do caminho de API testado. | A resposta HTTP da porta 8082 é um erro da API JSON com código `879`.                                              | Execute o comando PoC corrigido.                                                           |

## Premissas e Desconhecidos

Este laboratório usa o FOSSBilling 0.7.2 como alvo vulnerável de comparação porque pesquisas públicas de vulnerabilidade identificam versões do FOSSBilling anteriores a 0.8.0 como afetadas, e 0.7.2 é a última versão vulnerável usada na cadeia testada.

Este laboratório usa o FOSSBilling 0.8.0 como alvo corrigido de comparação porque metadados de aviso público identificam 0.8.0 como a versão corrigida.

Este laboratório foca no comportamento HTTP observável de:```text
POST /api/system/system/string_render

O laboratório demonstra que o FOSSBilling 0.7.2 renderiza a expressão Twig fornecida através do caminho da API HTTP, enquanto o FOSSBilling 0.8.0 não expõe a mesma chamada de API.

Este laboratório não afirma testar todos os recursos de renderização de templates do FOSSBilling. O CVE-2026-28496 também se relaciona a outros contextos de renderização Twig, como recursos de renderização de templates disponíveis dentro da aplicação.

Este laboratório não demonstra a cadeia completa de execução remota de código não autenticada. Ele valida o comportamento HTTP não autenticado observado no alvo local do FOSSBilling 0.7.2 e o compara com o FOSSBilling 0.8.0. A cadeia pública completa envolve comportamento adicional de autorização da API além da validação segura de expressão Twig mostrada aqui.

O laboratório não demonstra:

* execução remota de comandos,
* extração de credenciais,
* extração de banco de dados,
* instalação de extensões,
* escrita arbitrária de arquivos,
* persistência,
* upload de web shell,
* callbacks externos,
* ataques contra sistemas não laboratoriais,
* ou atividades de pós-exploração.

## Resumo da Causa Raiz

A causa raiz do CVE-2026-28496 é a renderização insegura de templates Twig.

O FOSSBilling usa Twig para renderizar templates dinâmicos. Em versões vulneráveis, uma string de template fornecida pode ser passada para a lógica de renderização Twig sem restrições de sandbox suficientes.

O comportamento vulnerável pode ser resumido como:```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

O design corrigido no FOSSBilling 0.8.0 reforça o comportamento vulnerável. Neste laboratório, o alvo corrigido não expõe mais a chamada de API testada:```json
{"result":null,"error":{"message":"Unknown API call system/system/string_render","code":879}}

## Análise do Código Fonte

O comportamento HTTP vulnerável é suportado pelo caminho do código-fonte no FOSSBilling 0.7.2.

O método da API recebe `_tpl` dos dados da solicitação e o passa para o renderizador do serviço do sistema.

Ponto de entrada vulnerável relevante:```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);
}

No FOSSBilling 0.7.2, `renderString()` tenta carregar o valor fornecido como um nome de template. Se isso falhar, trata o valor fornecido como uma string de template e o passa para `createTemplateFromString()`. Fluxo vulnerável simplificado:```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;
}

Contudo, a causa raiz é mais sensível à segurança do que a avaliação de expressões aritméticas. Em contextos de renderização vulneráveis, os templates Twig podem interagir com objetos da aplicação que estão presentes no ambiente do template. Pesquisas públicas descrevem cadeias de maior impacto onde objetos de contexto de API podem expor acesso a componentes internos da aplicação, como o contêiner de injeção de dependência.

Uma verificação de regressão em nível de fonte confirmou o comportamento mais profundo:```text
FOSSBilling 0.7.2:
  {{ guest.getDi() }}
  → DI_VISIBLE

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

O renderizador com sandbox cria e renderiza um modelo, mas captura violações de sandbox do Twig e as converte em um erro de aplicação controlado:```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(),
                ]
            );
        }
    }
}

A alteração relevante para a segurança é:```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

Isso fornece duas camadas de validação úteis:```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.

## Arquitetura do Laboratório

O laboratório executa duas instalações isoladas do FOSSBilling através do Docker Compose.```text
.
├── docker-compose.yml
├── vuln/
│   └── Dockerfile
├── patched/
│   └── Dockerfile
├── poc/
│   └── poc.py
├── scripts/
│   └── auto-install.sh
├── README.md
└── .gitignore

Service	Component	Version / Role
vuln	FOSSBilling	aplicação alvo vulnerável
patched	FOSSBilling	aplicação alvo corrigida
vuln-db	MariaDB	banco de dados para alvo vulnerável
patched-db	MariaDB	banco de dados para alvo corrigido
installer-vuln	curl sidecar	instala automaticamente alvo vulnerável
installer-patched	curl sidecar	instala automaticamente alvo corrigido

O laboratório usa versões fixas do FOSSBilling:

| Alvo                | Versão do FOSSBilling | Comportamento esperado                                   |
| --------------------- | ------------------: | --------------------------------------------------- |
| http://localhost:8081 |               0.7.2 | renderiza `{{ 7*7 }}` através do caminho da API vulnerável |
| http://localhost:8082 |               0.8.0 | não expõe o mesmo comportamento vulnerável da API    |

Os sidecars do instalador são executados automaticamente durante `docker compose up`. Eles inicializam ambos os alvos FOSSBilling com credenciais de banco de dados descartáveis locais e depois saem.

O laboratório não cria ou modifica a rota da API vulnerável.

A rota `/api/system/system/string_render` é fornecida pela aplicação FOSSBilling no alvo vulnerável 0.7.2 após a instalação. O laboratório Docker apenas instala a aplicação através do seu fluxo normal de instalador e depois envia uma requisição HTTP ao endpoint existente da aplicação.

O alvo corrigido 0.8.0 retorna `Unknown API call system/system/string_render`, o que confirma que o comportamento da rota testado vem da própria versão da aplicação, e não de uma rota criada pelo laboratório.

## Requisitos

* Docker Desktop ou Docker Engine
* Docker Compose v2
* Python 3
* Acesso à Internet durante o primeiro pull da imagem Docker

Nenhum pacote Python de terceiros é necessário. O PoC utiliza apenas módulos da biblioteca padrão do Python.

## Início Rápido

Inicie o laboratório a partir de um estado limpo:```bash
docker compose down -v --remove-orphans
docker compose up -d --build

O PoC é apenas HTTP. Ele não chama Docker, Docker Compose, comandos de shell, WP-CLI ou APIs de contêiner.

## Resultados Esperados

### Alvo Vulnerável

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

A diferença importante é:```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

Para uma validação de causa raiz mais aprofundada no nível do código-fonte, o acesso a métodos é uma prova mais forte do problema subjacente. No entanto, o PoC público neste repositório utiliza a expressão aritmética mais segura para evitar demonstrar uma cadeia de alto impacto.

## Reprodução Manual de HTTP com curl

Sonda vulnerável:```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 }}"}'

## Impacto

Server-Side Template Injection in a billing and client management platform is security-sensitive because the application may store customer records, billing data, server credentials, payment configuration, and administrator-controlled automation logic.

O payload de laboratório demonstrado é inofensivo e apenas avalia:```twig
{{ 7*7 }}

Ações de monitoramento recomendadas:

* Revise os logs de acesso do servidor web para `/api/system/system/string_render`.
* Revise solicitações contendo `_tpl` em corpos de requisições JSON.
* Revise solicitações contendo sintaxe do Twig, como `{{` e `}}`.
* Revise respostas bem-sucedidas da API que contenham saída renderizada de template.
* Revise respostas de API com falha para tentativas suspeitas de renderização de template.
* Revise a atividade do administrador se houver suspeita de exploração.
* Revise alterações de configuração de template, e-mail, mailer em massa e adaptador de pagamento.
* Revise logs de aplicação para erros de renderização de template ou chamadas de API inesperadas.

Ideia de detecção de alto sinal:```text
POST request to /api/system/system/string_render
AND request body contains "_tpl"
AND request body contains "{{"

## Mitigação e Notas de Correção

Atualize o FOSSBilling para a versão 0.8.0 ou posterior.

Para ambientes de produção, atualize para a versão mais recente disponível, em vez de parar na versão de comparação de laboratório.

Etapas de mitigação recomendadas:

* Atualize o FOSSBilling para 0.8.0 ou posterior.
* Confirme que a versão instalada não está no intervalo afetado.
* Restrinja o acesso público a caminhos de API administrativos quando possível.
* Revise os logs de acesso web para requisições a `/api/system/system/string_render`.
* Revise templates, templates de e-mail, mailers em massa e adaptadores de pagamento personalizados para sintaxe Twig suspeita.
* Rotacione segredos se houver suspeita de exploração.
* Revise registros de clientes, faturamento, pagamento e gerenciamento de servidores para acesso não autorizado.
* Trate as regras de WAF ou bloqueios de proxy reverso como controles temporários, não como substituições para a atualização.

Lições de engenharia de segurança:

* Não renderize strings de template não confiáveis em um contexto de aplicação privilegiado.
* Não exponha contêineres de serviço da aplicação a contextos de template.
* Use renderização de template em sandbox para recursos de template controlados pelo usuário ou administrador.
* Negue acesso a métodos e propriedades a menos que explicitamente necessário.
* Mantenha as falhas de autorização da API explícitas e feche em caso de falha.
* Trate os recursos de renderização de template como superfícies adjacentes à execução de código.

## Comandos Úteis de Verificação

Verificar o status do container:```bash
docker compose ps -a

Solicitação de patch manual:```bash
curl -i -X POST \
  'http://127.0.0.1:8082/api/system/system/string_render' \
  -H 'Content-Type: application/json' \
  --data '{"_tpl":"{{ 7*7 }}"}'

Inspecione o renderizador de sandbox corrigido a partir da árvore de origem verificada:```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

Verifique os cabeçalhos de resposta do FOSSBilling:```bash
curl -i http://127.0.0.1:8081 | grep -i 'x-fossbilling-version'
curl -i http://127.0.0.1:8082 | grep -i 'x-fossbilling-version'

## Limites de Segurança

Este laboratório é apenas para pesquisa de segurança local e demonstração controlada.

Não execute o PoC ou requisições curl manuais contra sistemas que você não possui ou para os quais não tem autorização explícita para testar.

Não use credenciais reais de produção, dados de clientes, dados de pagamento, chaves de API ou segredos de produção neste laboratório.

O escopo pretendido é limitado a serviços Docker locais, tais como:```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082

## Referências

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

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

* VulnCheck: Bypass de Autenticação e SSTI do Twig para RCE não autenticado no FOSSBilling
  https://www.vulncheck.com/blog/fossbilling-auth-bypass-ssti-rce

* Documentação Docker do FOSSBilling
  https://docs.fossbilling.org/getting-started/docker/

* Repositório GitHub do FOSSBilling
  https://github.com/FOSSBilling/FOSSBilling

* Imagem Docker do FOSSBilling
  https://hub.docker.com/r/fossbilling/fossbilling

* Documentação do Twig: Extensão Sandbox
  https://twig.symfony.com/doc/3.x/sandbox.html

CVE-2026-28496-Lab

Mais Populares

Resumo da Correção na Fonte

Como Funciona a Validação

Detecção e Monitoramento

Limpeza

vuln	0.7.2	Alvo de comparação vulnerável	http://localhost:8081
patched	0.8.0	Alvo de comparação corrigido	http://localhost:8082