CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-4370

CVE-2026-4370: Critical Authentication Bypass in Canonical Juju Dqlite Cluster

Amit Schendel
Amit Schendel
Senior Security Researcher

Apr 2, 2026·5 min read·144 visits

Executive Summary (TL;DR)

Unauthenticated remote attackers can bypass TLS validation to join the Juju Dqlite database cluster, granting full read/write access to the controller's state and resulting in complete environment compromise.

Canonical Juju versions 3.2.0 through 3.6.19 and 4.0 through 4.0.4 contain a critical vulnerability in the internal Dqlite database cluster. The system fails to enforce TLS client certificate validation during the node join handshake on port 17666. An unauthenticated remote attacker can exploit this flaw to join the cluster, gaining full read and write access to the underlying state database.

Vulnerability Overview

Canonical Juju utilizes Dqlite (Distributed SQLite) as a high-availability database cluster to manage the state of models and units. The Dqlite service runs on the Juju controller and communicates over port 17666. This internal cluster relies on mutual TLS (mTLS) to authenticate nodes and secure inter-node communication.

CVE-2026-4370 represents a critical authentication bypass within this Dqlite component. The vulnerability exists due to a failure to validate client certificates during the cluster-join handshake. This flaw is categorized under CWE-295 (Improper Certificate Validation) and CWE-306 (Missing Authentication for Critical Function).

Unauthenticated attackers with network access to port 17666 can join the database cluster without possessing a valid internal certificate. Successful exploitation grants full read and write access to the underlying Juju state database. The compromise of the Dqlite database enables control over all environments managed by the Juju controller.

Root Cause Analysis

The Dqlite cluster-join handshake logic coordinates the addition of new nodes to the existing high-availability cluster. A new node initiates a Join() request over a TLS connection to integrate with the cluster. The Juju controller is designed to enforce mTLS to verify the joining node's identity against the internal certificate authority.

The vulnerability stems from a specific failure in the server-side TLS configuration of the Juju controller. The TLS implementation accepts the incoming connection but fails to enforce the requirement for a valid, Juju-issued client certificate. This oversight allows an attacker to complete the TLS handshake anonymously.

Because the handshake succeeds without validation, the controller registers the unauthenticated node as a legitimate cluster member. This registration triggers the Dqlite replication protocol to begin state synchronization. The underlying issue is a disconnect between the transport-layer security requirements and the application-layer cluster membership logic.

Code Analysis and Application-Layer Defenses

During the vulnerability lifecycle, developers introduced commit 001318f51ac456602aef20b123684f1eeeae9a77 to harden application-layer logic. This patch tightens the state management routines in domain/application/state/unit.go specifically concerning the UpdateUnitCharm function. The modification ensures the target charm is explicitly authorized for the parent application before allowing a unit update.

The following conceptual code illustrates the vulnerable application-layer logic before the patch, which relied on the assumption that only authenticated cluster members could invoke state changes:

// Pre-patch logic omitted authorization checks
func (s *State) UpdateUnitCharm(unitUUID string, charmID string) error {
    // Vulnerable: Direct update without parent app authorization
    return s.db.Exec("UPDATE unit SET charm_id = ? WHERE uuid = ?", charmID, unitUUID)
}

This application-level patch provides zero protection against an adversary exploiting CVE-2026-4370. Because the TLS flaw grants direct, unauthenticated SQL access to the Dqlite database, an attacker completely bypasses the UpdateUnitCharm Go-level logic. An adversary can execute raw SQL UPDATE statements on the unit table directly over the compromised Dqlite replication channel.

Exploitation Methodology

An attacker initiates the exploit chain by identifying a Juju controller with an exposed Dqlite port, defaulting to 17666. The attacker utilizes a custom or modified go-dqlite client to establish a TCP connection to this endpoint. The exploit requires direct network reachability to the controller.

The attacker sends a Join request over the established connection. The attacker specifically omits a valid client certificate during the TLS handshake. The controller processes the request and, due to the missing validation logic, accepts the unauthenticated connection.

Following the successful join operation, the controller immediately begins replicating the SQLite database state to the attacker's node. The attacker receives a complete, live copy of the Juju environment's configuration. The replication process exposes all stored administrative data.

The attacker executes the final phase by injecting malicious SQL commands into their local Dqlite node. These commands replicate back to the controller's primary database. The attacker can alter unit configurations, deploy malicious charms, or extract plaintext cloud credentials stored within the database schema.

Impact Assessment

CVE-2026-4370 carries a critical CVSS v3.1 score of 10.0 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H). The network attack vector and the lack of required privileges maximize the exploitability score. The changed scope reflects the complete compromise of the underlying environments managed by the vulnerable Juju controller.

The confidentiality impact is severe. The Dqlite database stores highly sensitive operational data, including administrative credentials, environment variables, and cloud provider secrets. An attacker can extract these secrets to pivot from the Juju management plane directly into the connected cloud infrastructure.

The integrity and availability impacts result in total system compromise. The attacker possesses full write access to the internal Juju state. They can destructively modify the database, deploy malicious workloads via rogue charms, or dismantle the entire managed environment by issuing arbitrary SQL commands.

Remediation and Mitigation

Administrators must upgrade Juju controllers running vulnerable 3.x versions to 3.6.20 immediately. Environments running vulnerable 4.0.x versions must upgrade to 4.0.5. These patched releases correct the TLS configuration to enforce strict mTLS client certificate validation during the Dqlite join process.

Organizations unable to patch immediately must implement network-level mitigation strategies. Administrators must deploy strict firewall rules restricting access to port 17666. This port must only be reachable by authorized internal Juju cluster nodes and must be strictly isolated from the public internet or untrusted networks.

Security teams should monitor network traffic for anomalous connection attempts to port 17666 from unrecognized IP addresses. Administrators should review Juju controller logs for unexpected cluster membership changes or unauthorized Dqlite join events. Deploying Nuclei detection templates can identify exposed Dqlite endpoints, though active protocol interaction is required to confirm vulnerability.

Fix Analysis (1)

Technical Appendix

CVSS Score
10.0/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
EPSS Probability
0.03%
Top 100% most exploited

Affected Systems

Canonical Juju ControllerJuju Dqlite Database Cluster

Affected Versions Detail

Product
Affected Versions
Fixed Version
Juju
Canonical
3.2.0 - 3.6.193.6.20
Juju
Canonical
4.0 - 4.0.44.0.5
AttributeDetail
CWE IDCWE-295, CWE-306
Attack VectorNetwork
Privileges RequiredNone
CVSS v3.1 Score10.0
EPSS Score0.00035 (0.03%)
Exploit StatusPublicly Available / Proof-of-Concept

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1557Adversary-in-the-Middle
Credential Access
CWE-295
Improper Certificate Validation

The software does not validate, or incorrectly validates, a certificate.

Vulnerability Timeline

Related application-layer tightening commits observed in the Juju repository
2026-03-11
Vulnerability published by Canonical/NVD
2026-04-01
Patch released (Juju 3.6.20 and 4.0.5)
2026-04-01

References & Sources

  • [1]GHSA Advisory
  • [2]NVD Record
  • [3]CVE.org Record
  • [4]Ubuntu Security Advisory
  • [5]Related Juju Commit

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 3 hours ago•CVE-2026-61618
6.9

CVE-2026-61618: Improper Input Validation of KZG Accumulator Limbs in snark-verifier

CVE-2026-61618 (GHSA-265x-v3qf-ff6p) is an improper input validation vulnerability (CWE-20) in Axiom Crypto's snark-verifier library prior to version 0.2.5. The library decodes KZG accumulator public-instance limbs without enforcing canonical bit-width bounds prior to elliptic curve coordinate reconstruction. In the Ethereum Virtual Machine (EVM) loader path, the generated Yul bytecode validates that reconstructed affine coordinates lie on the elliptic curve, but fails to verify that the constituent limbs respect their allocated bit-widths, allowing non-canonical proof representations. In the native Rust execution path, accumulator decoding relies on unchecked assertions and unwraps, allowing malformed public instances to trigger an unhandled process panic.

Amit Schendel
Amit Schendel
3 views•12 min read
•about 4 hours ago•CVE-2026-63496
7.8

CVE-2026-63496: OS Command Injection in @augment-vir/node grep() Helper

An OS command injection vulnerability (CWE-78) exists in the @augment-vir/node package prior to version 31.73.5. The grep() utility function builds a shell command string by interpolating caller-supplied search patterns inside double quotes and executes the string through bash via runShellCommand(). Because bash evaluates command substitution expressions inside double-quoted strings, an attacker controlling the search pattern input can execute arbitrary OS commands with the privileges of the Node.js runtime.

Alon Barad
Alon Barad
4 views•8 min read
•about 16 hours ago•CVE-2026-53998
10.0

CVE-2026-53998: Format String Injection and Information Disclosure in Arize Phoenix applyChatTemplate

CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.

Amit Schendel
Amit Schendel
9 views•9 min read
•about 17 hours ago•CVE-2026-63634
6.9

CVE-2026-63634: EVM Calldata Padding Gas Drainage in pympp Fee-Payer Verification

CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 18 hours ago•CVE-2026-14265
7.5

CVE-2026-14265: Remote Code Execution via Unsafe Deserialization in AWS Advanced JDBC Wrapper

CVE-2026-14265 (GHSA-c5q4-97jw-jggh) is a high-severity Remote Code Execution (RCE) vulnerability in the Amazon Web Services (AWS) Advanced JDBC Wrapper versions 3.3.0 through 4.0.0. The defect resides in the `RemoteQueryCachePlugin` and its underlying `CachedResultSet` implementation, which uses an unfiltered `java.io.ObjectInputStream` to deserialize cached SQL query results retrieved from external Redis or Valkey backends. An attacker with write access to the shared cache infrastructure can inject serialized Java gadget chains into cache keys, achieving arbitrary code execution within the JVM context of any application server consuming the cached entries.

Amit Schendel
Amit Schendel
6 views•10 min read
•about 19 hours ago•CVE-2026-63672
6.1

CVE-2026-63672: User-Controlled Identity Provider Selection in EGroupware SAML Authentication

CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.

Amit Schendel
Amit Schendel
7 views•9 min read