Maven & Gradle Security Vulnerabilities in 2026: CVE-2026-34477, MavenGate & the Log4j Problem That Won't DieVulnérabilités Maven & Gradle en 2026 : CVE-2026-34477, MavenGate & le Problème Log4j qui Persiste

Java’s build tooling — Maven and Gradle — powers billions of daily builds, yet security in the Java supply chain follows a familiar pattern: a vulnerability is discovered, a fraction of projects patch it, and the rest carry the exposure for years. CVE-2026-34477, published in April 2026, is a textbook example: the verifyHostName attribute in Apache Log4j Core’s <Ssl> configuration has been silently ignored since version 2.12.0 — meaning any project that configured TLS hostname verification through XML thought it was protected, when it was not. Separately, the MavenGate research shows that 6,170 domains corresponding to Maven Central dependencies are available for purchase today, ready to be turned into supply chain attacks. And four years after Log4Shell, Sonatype reports that 13% of Log4j downloads in 2025 were still for vulnerable versions. This guide covers the real CVEs, the attack patterns, and the concrete steps to harden your Maven and Gradle pipeline.

L’outillage de build Java — Maven et Gradle — alimente des milliards de builds quotidiens, pourtant la sécurité dans la chaîne d’approvisionnement Java suit un schéma familier : une vulnérabilité est découverte, une fraction des projets patche, le reste conserve l’exposition pendant des années. CVE-2026-34477, publiée en avril 2026, en est un exemple typique : l’attribut verifyHostName dans la configuration <Ssl> d’Apache Log4j Core a été silencieusement ignoré depuis la version 2.12.0 — ce qui signifie que tout projet ayant configuré la vérification TLS du nom d’hôte via XML croyait être protégé, alors qu’il ne l’était pas. Par ailleurs, la recherche MavenGate montre que 6 170 domaines correspondant à des dépendances Maven Central sont disponibles à l’achat aujourd’hui, prêts à être transformés en attaques supply chain. Et quatre ans après Log4Shell, Sonatype rapporte que 13 % des téléchargements Log4j en 2025 étaient encore des versions vulnérables. Ce guide couvre les CVE réelles, les patterns d’attaque et les étapes concrètes pour durcir votre pipeline Maven et Gradle.

CVE-2026-34477: Log4j TLS Hostname Bypass — Silent Since 2.12.0

CVE-2026-34477 : Contournement TLS Log4j — Silencieux Depuis 2.12.0

In April 2026, Apache disclosed CVE-2026-34477, a man-in-the-middle vulnerability in Apache Log4j Core affecting all versions from 2.12.0 through 2.25.3 — and the alpha/beta branch 3.0.0-alpha1 through 3.0.0-beta3. The vulnerability is an incomplete fix for CVE-2025-68161, which had already tried to address hostname verification in TLS-enabled appenders.

En avril 2026, Apache a divulgué CVE-2026-34477, une vulnérabilité de type man-in-the-middle dans Apache Log4j Core affectant toutes les versions de 2.12.0 à 2.25.3 — ainsi que la branche alpha/beta 3.0.0-alpha1 à 3.0.0-beta3. Cette vulnérabilité est un correctif incomplet de CVE-2025-68161, qui avait déjà tenté de traiter la vérification du nom d’hôte dans les appenders TLS.

Root cause: Hostname verification was only enforced when enabled via the log4j2.sslVerifyHostName system property. When a developer used the verifyHostName XML attribute inside a <Ssl> element — the documented configuration approach — the attribute was silently ignored. Any project that trusted XML-based TLS configuration for SMTP, Socket, or Syslog appenders was running with hostname verification disabled, unaware.

Cause racine : La vérification du nom d’hôte n’était appliquée que lorsqu’elle était activée via la propriété système log4j2.sslVerifyHostName. Lorsqu’un développeur utilisait l’attribut XML verifyHostName dans un élément <Ssl> — l’approche de configuration documentée — l’attribut était silencieusement ignoré. Tout projet se fiant à la configuration TLS XML pour les appenders SMTP, Socket ou Syslog fonctionnait sans vérification du nom d’hôte, sans en avoir conscience.

Attack scenario

Scénario d’attaque

A network attacker positioned between the application server and the logging destination (e.g., a remote syslog server, SMTP relay) can present any certificate issued by a CA trusted by the JVM’s default truststore. Since hostname verification is disabled, the TLS handshake completes successfully — and the attacker can intercept or tamper with log data, which may include authentication tokens, stack traces with internal paths, or session identifiers. The attack requires AC:H (network position), hence the moderate CVSS score of 4.8. In corporate environments with shared network segments, this is achievable.

Un attaquant réseau positionné entre le serveur applicatif et la destination de logging (ex : serveur syslog distant, relais SMTP) peut présenter n’importe quel certificat émis par une CA de confiance du truststore JVM par défaut. Comme la vérification du nom d’hôte est désactivée, le handshake TLS aboutit — et l’attaquant peut intercepter ou altérer les données de log, qui peuvent inclure des tokens d’authentification, des stack traces avec des chemins internes, ou des identifiants de session. L’attaque requiert AC:H (position réseau), d’où le score CVSS modéré de 4.8. Dans les environnements d’entreprise avec des segments réseau partagés, c’est réalisable.

Remediation

Remédiation

Upgrade to Apache Log4j Core 2.25.4 (or later). If you cannot upgrade immediately, enable hostname verification via the system property workaround:

Mettez à jour vers Apache Log4j Core 2.25.4 (ou plus récent). Si vous ne pouvez pas mettre à jour immédiatement, activez la vérification du nom d’hôte via la propriété système :

<!-- pom.xml — upgrade log4j-core to patched version -->
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.25.4</version>
</dependency>

<!-- Workaround (if upgrade not possible): add to JVM args -->
<!-- -Dlog4j2.sslVerifyHostName=true -->

// build.gradle (Kotlin DSL) — upgrade log4j-core
dependencies {
    implementation("org.apache.logging.log4j:log4j-core:2.25.4")
}

Also verify that no transitive dependency re-introduces an older version. In Maven:

Vérifiez également qu’aucune dépendance transitive ne réintroduit une version plus ancienne. Avec Maven :

# Detect all log4j-core versions in your dependency tree
mvn dependency:tree -Dincludes=org.apache.logging.log4j:log4j-core

# Gradle equivalent
./gradlew dependencies --configuration runtimeClasspath | grep log4j-core

The Log4Shell Hangover: 13% of Downloads Still Vulnerable in 2025

La Gueule de Bois Log4Shell : 13 % des Téléchargements Encore Vulnérables en 2025

CVE-2021-44228 (Log4Shell, CVSS 10.0) was disclosed in December 2021 and is arguably the most severe Java vulnerability ever published. Yet Sonatype’s analysis of Maven Central data shows that in 2025, 40 million of the 300 million Log4j downloads were for vulnerable versions — 13% of all downloads, years after a complete patch was available. Contrast Security independently confirmed that 12% of Java applications were still running vulnerable Log4j versions as of their 2025 reporting.

CVE-2021-44228 (Log4Shell, CVSS 10.0) a été divulguée en décembre 2021 et est sans doute la vulnérabilité Java la plus grave jamais publiée. Pourtant, l’analyse par Sonatype des données Maven Central montre qu’en 2025, 40 millions des 300 millions de téléchargements Log4j étaient pour des versions vulnérables — 13 % de tous les téléchargements, des années après la disponibilité d’un correctif complet. Contrast Security a indépendamment confirmé que 12 % des applications Java exécutaient encore des versions vulnérables de Log4j selon leur rapport 2025.

Why does this persist? Java applications have deep dependency trees. Log4j is often an indirect dependency — included by a framework, a cloud SDK, or a monitoring agent rather than by the application developer directly. According to Black Duck’s 2025 OSSRA report, 64% of OSS components in production codebases are transitive dependencies. You cannot patch what you cannot see. The emergency patch cycle of December 2021 addressed direct dependencies, but transitive inclusions inside bundled JARs, shadow services, and archived deployments quietly remained.

Pourquoi cela persiste-t-il ? Les applications Java ont des arbres de dépendances profonds. Log4j est souvent une dépendance indirecte — incluse par un framework, un SDK cloud ou un agent de monitoring plutôt que directement par le développeur. Selon le rapport OSSRA 2025 de Black Duck, 64 % des composants OSS dans les codebases de production sont des dépendances transitives. On ne peut pas patcher ce qu’on ne voit pas. Le cycle de patch d’urgence de décembre 2021 a traité les dépendances directes, mais les inclusions transitives dans les JARs intégrés, les services secondaires et les déploiements archivés sont silencieusement restés.

Detecting Log4j in your full dependency graph requires two commands — one per build tool:

Détecter Log4j dans votre graphe de dépendances complet requiert deux commandes — une par outil de build :

# Maven: find all log4j artifacts (including transitive)
mvn dependency:tree | grep -i "log4j"

# Deeper search including shaded/bundled JARs
mvn dependency:tree -Dincludes=org.apache.logging.log4j:*

# Gradle: full dependency tree search
./gradlew dependencies | grep -i log4j

# Gradle: targeted insight
./gradlew -q dependencyInsight \
  --dependency org.apache.logging.log4j \
  --configuration runtimeClasspath

MavenGate: 6,170 Maven Central Dependencies Open to Domain Hijacking

MavenGate : 6 170 Dépendances Maven Central Ouvertes au Détournement de Domaine

Maven’s Group ID system uses reverse-domain notation (e.g., com.example corresponds to example.com). When a library maintainer abandons a project and lets the underlying domain expire, any attacker can purchase that domain and claim ownership of the corresponding Group ID on Maven Central — then publish a malicious version of the library that gets fetched by automated build systems.

Le système Group ID de Maven utilise la notation de domaine inversé (ex : com.example correspond à example.com). Lorsqu’un mainteneur de bibliothèque abandonne un projet et laisse expirer le domaine sous-jacent, n’importe quel attaquant peut acheter ce domaine et revendiquer la propriété du Group ID correspondant sur Maven Central — puis publier une version malveillante de la bibliothèque qui sera récupérée par les systèmes de build automatisés.

Security researchers examined 33,939 domain-based Group IDs on Maven Central and found that 6,170 of them (18%) had expired or purchasable domains. This is not a theoretical risk: the 2023 MavenGate proof-of-concept demonstrated the attack worked end-to-end, with a malicious artifact successfully fetched by a real build. The affected libraries included widely-used frameworks with millions of downloads.

Des chercheurs en sécurité ont examiné 33 939 Group ID basés sur des domaines dans Maven Central et ont trouvé que 6 170 d’entre eux (18 %) avaient des domaines expirés ou disponibles à l’achat. Ce n’est pas un risque théorique : la preuve de concept MavenGate 2023 a démontré que l’attaque fonctionnait de bout en bout, avec un artefact malveillant récupéré avec succès par un vrai build. Les bibliothèques affectées incluaient des frameworks très utilisés avec des millions de téléchargements.

Similarly, research on Maven-Hijack (published at the 2025 Workshop on Software Supply Chain Offensive Research) demonstrates how Maven’s dependency resolution order and Java’s classloading mechanism can be exploited together: an attacker who controls a dependency that appears earlier in the classpath can shadow legitimate classes with malicious ones without modifying the target artifact at all.

De même, la recherche sur Maven-Hijack (présentée au Workshop on Software Supply Chain Offensive Research 2025) démontre comment l’ordre de résolution des dépendances de Maven et le mécanisme de chargement des classes Java peuvent être exploités conjointement : un attaquant qui contrôle une dépendance apparaissant plus tôt dans le classpath peut éclipser des classes légitimes avec des classes malveillantes sans modifier du tout l’artefact cible.

Protection against domain hijacking

Protection contre le détournement de domaine

<!-- Maven: pin artifact checksums in your CI pipeline -->
<!-- Use Maven Enforcer plugin to require checksums -->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-enforcer-plugin</artifactId>
  <version>3.5.0</version>
  <executions>
    <execution>
      <id>enforce-checksums</id>
      <goals><goal>enforce</goal></goals>
      <configuration>
        <rules>
          <requireSnapshotVersion>
            <failWhenParentIsSnapshot>true</failWhenParentIsSnapshot>
          </requireSnapshotVersion>
          <!-- Block HTTP repositories -->
          <requireNoRepositories>
            <allowedRepositories>
              <id>central</id>
            </allowedRepositories>
          </requireNoRepositories>
        </rules>
      </configuration>
    </execution>
  </executions>
</plugin>

// build.gradle (Kotlin DSL): restrict to HTTPS repositories only
repositories {
    maven {
        url = uri("https://repo1.maven.org/maven2/")
        // Reject any non-HTTPS repo
        content { includeGroupByRegex(".*") }
    }
}

// Enable dependency verification
// Run: ./gradlew --write-verification-metadata sha256
// This generates gradle/verification-metadata.xml with checksums

OWASP Dependency-Check: Scanning Maven and Gradle Projects for CVEs

OWASP Dependency-Check : Scanner les Projets Maven et Gradle pour les CVE

OWASP Dependency-Check is the standard tool for identifying known CVEs in Java dependencies. Version 12.2.2 (released May 3, 2026) integrates directly into Maven and Gradle build pipelines and correlates your dependency tree against the NVD database, Sonatype OSS Index, and GitHub Advisory Database. Black Duck’s 2025 OSSRA found that 81% of risk-assessed codebases contained at least one high- or critical-risk open source dependency — most of which Dependency-Check would have flagged.

OWASP Dependency-Check est l’outil standard pour identifier les CVE connues dans les dépendances Java. La version 12.2.2 (sortie le 3 mai 2026) s’intègre directement dans les pipelines de build Maven et Gradle et corrèle votre arbre de dépendances avec la base de données NVD, Sonatype OSS Index et GitHub Advisory Database. Black Duck’s 2025 OSSRA a trouvé que 81 % des codebases évaluées contenaient au moins une dépendance open source à risque élevé ou critique — la plupart desquelles Dependency-Check aurait signalées.

Maven integration

Intégration Maven

<!-- pom.xml: add OWASP Dependency-Check plugin -->
<plugin>
  <groupId>org.owasp</groupId>
  <artifactId>dependency-check-maven</artifactId>
  <version>12.2.2</version>
  <configuration>
    <!-- Fail build if any dependency has CVSS score >= 7.0 -->
    <failBuildOnCVSS>7</failBuildOnCVSS>
    <!-- Include transitive dependencies -->
    <skipTransitiveDependencies>false</skipTransitiveDependencies>
    <!-- Formats: HTML, JSON, SARIF (for GitHub Code Scanning) -->
    <format>ALL</format>
    <outputDirectory>${project.build.directory}/dependency-check-report</outputDirectory>
  </configuration>
  <executions>
    <execution>
      <goals><goal>check</goal></goals>
    </execution>
  </executions>
</plugin>

# Run manually
mvn org.owasp:dependency-check-maven:check

# View the HTML report
open target/dependency-check-report/dependency-check-report.html

Gradle integration

Intégration Gradle

// build.gradle (Kotlin DSL)
plugins {
    id("org.owasp.dependencycheck") version "12.2.2"
}

dependencyCheck {
    // Fail the build for CVSS >= 7.0
    failBuildOnCVSS = 7.0f
    // Output formats
    formats = listOf("HTML", "JSON", "SARIF")
    // Check transitive dependencies (default: true)
    analyzers {
        experimentalEnabled = false
    }
}

# Run the check
./gradlew dependencyCheckAnalyze

# The report lands in build/reports/dependency-check-report.html

The Hidden Dependency Problem: 50% of Popular Java Projects Contain Unknown Vulnerable Libs

Le Problème des Dépendances Cachées : 50 % des Projets Java Populaires Contiennent des Librairies Vulnérables Inconnues

A 2026 study published on arXiv (“Uncovering Hidden Inclusions of Vulnerable Dependencies in Real-World Java Projects”) analyzed 1,808 popular open-source Java Maven projects on GitHub. It found that nearly 50% contained at least one modified or hidden dependency associated with a known CVE, with an average of more than eight such hidden vulnerable dependencies per affected project. These are not in your pom.xml. They are inside bundled JARs, shaded assemblies, or repackaged libraries — invisible to standard dependency tree analysis.

Une étude 2026 publiée sur arXiv (« Uncovering Hidden Inclusions of Vulnerable Dependencies in Real-World Java Projects ») a analysé 1 808 projets Java Maven open source populaires sur GitHub. Elle a trouvé que près de 50 % contenaient au moins une dépendance modifiée ou cachée associée à une CVE connue, avec une moyenne de plus de huit telles dépendances vulnérables cachées par projet affecté. Celles-ci ne sont pas dans votre pom.xml. Elles se trouvent dans des JARs intégrés, des assemblages shadés ou des librairies reconditionnées — invisibles à l’analyse standard de l’arbre de dépendances.

This is why the Maven Shade Plugin and Gradle Shadow JAR require special attention: when you shade (relocate/bundle) dependencies, vulnerability scanners lose track of the bundled library’s identity. Best practice:

C’est pourquoi le Maven Shade Plugin et Gradle Shadow JAR requièrent une attention particulière : lorsque vous shadown (relocalisez/intégrez) des dépendances, les scanners de vulnérabilités perdent la trace de l’identité de la librairie intégrée. Bonne pratique :

<!-- pom.xml: DO NOT shade security-sensitive libs -->
<!-- Instead of bundling log4j/jackson/spring-security, keep them as runtime deps -->

<!-- If you must shade, keep a manifest of shaded artifacts -->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-shade-plugin</artifactId>
  <version>3.6.0</version>
  <configuration>
    <!-- Explicitly list what is being bundled for audit trail -->
    <artifactSet>
      <includes>
        <!-- only bundle your own code, not security-sensitive transitive deps -->
        <include>com.yourcompany:*</include>
      </includes>
    </artifactSet>
  </configuration>
</plugin>

Maven & Gradle Build Security: 8 Hardening Steps

Sécurité des Builds Maven & Gradle : 8 Étapes de Durcissement

Beyond CVE scanning, securing the build pipeline itself is critical. Java’s build tools have specific security controls that are off by default.

Au-delà du scanning de CVE, sécuriser le pipeline de build lui-même est critique. Les outils de build Java disposent de contrôles de sécurité spécifiques qui sont désactivés par défaut.

Pin the Gradle/Maven wrapper binary

Pinner le binaire Gradle/Maven wrapper

Both wrappers (mvnw and gradlew) download the build tool binary from a URL on first use. If the distribution URL points to HTTP, or the binary is not checksum-verified, an attacker with MITM access can substitute the build tool itself — compromising every artifact it produces. Always pin with a hash:

Les deux wrappers (mvnw et gradlew) téléchargent le binaire de l’outil de build depuis une URL lors de la première utilisation. Si l’URL de distribution pointe vers HTTP, ou si le binaire n’est pas vérifié par somme de contrôle, un attaquant avec accès MITM peut substituer l’outil de build lui-même — compromettant chaque artefact qu’il produit. Toujours pinner avec un hash :

# gradle/wrapper/gradle-wrapper.properties
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
# Always HTTPS
distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
# Pin the expected SHA-256 checksum
distributionSha256Sum=a4b4158601f8636cdeeab09bd76afb640030bb5b144aafe261a5e8af027dc612
zipStorePath=wrapper/dists

# .mvn/wrapper/maven-wrapper.properties
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip
wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.3.2/maven-wrapper-3.3.2.jar

Gradle Build Scans and Supply Chain: What GitHub Knows That You Don't

Gradle Build Scans et Supply Chain : Ce que GitHub Sait et Pas Vous

Gradle’s blog post on supply chain security with GitHub (“Avoiding the Next Supply Chain Disaster with GitHub and Gradle”) identifies three concrete controls that significantly reduce exposure:

Le billet de blog de Gradle sur la sécurité supply chain avec GitHub (« Avoiding the Next Supply Chain Disaster with GitHub and Gradle ») identifie trois contrôles concrets qui réduisent significativement l’exposition :

• Dependency Graph Submission API — submit your Gradle dependency graph to GitHub after every build. This populates Dependabot Alerts with your actual transitive graph, not just what is declared in your build files.
• Dependency Graph Submission API — soumettre le graphe de dépendances Gradle à GitHub après chaque build. Cela alimente les alertes Dependabot avec votre graphe transitif réel, pas seulement ce qui est déclaré dans vos fichiers de build.
• Develocity Build Cache Integrity — ensure your remote build cache (if used) is authenticated and its TLS certificates are verified. A poisoned build cache can inject malicious bytecode without touching any source file.
• Intégrité du cache Develocity — s’assurer que votre cache de build distant (si utilisé) est authentifié et que ses certificats TLS sont vérifiés. Un cache de build empôisonné peut injecter du bytecode malveillant sans toucher aucun fichier source.
• Gradle Verification Metadata — gradle/verification-metadata.xml locks every dependency (including plugins) to a known SHA-256 checksum. Any tampering causes the build to fail immediately.
• Métadonnées de vérification Gradle — gradle/verification-metadata.xml verrouille chaque dépendance (y compris les plugins) à un checksum SHA-256 connu. Toute altération fait échouer le build immédiatement.

# Generate verification-metadata.xml for all current dependencies
./gradlew --write-verification-metadata sha256 help

# Verify integrity (fails on tampered JARs)
./gradlew --verify-verification-metadata build

Frequently Asked Questions

Questions fréquentes