critical

CVE

CVE-2026-111943, CVE-2026-113812, CVE-2026-114583, CVE-2026-115557, CVE-2026-115570, CVE-2026-115929, CVE-2026-118696, CVE-2026-118697, CVE-2026-133949

CWE

CWE-295, CWE-299, CWE-326

Affected Surface

  • `uv` versions earlier than `0.13.4` from PyPI, standalone installers, or pinned binaries
  • Developer workstations, CI runners, and container images that used `uv`'s default bundled Mozilla root certificates to reach PyPI, `--index-url` mirrors, or other HTTPS package hosts
  • Environments that replaced `uv`'s defaults with `SSL_CERT_FILE`, `SSL_CERT_DIR`, or system certificates if those trust stores still included the compromised emSign lineage
  • Broader language runtimes, desktop runtimes, IDEs, GitHub Actions, and package managers affected by the eight weak eMudhra intermediate CA keys (`CVE-2026-111943`), including `pypa/gh-action-pypi-publish` (`< 1.14.3` / `v1`, `GHSA-5xjx-3w67-w9x9`), JetBrains Toolbox App (`< 3.9.1` / `< 3.8.2`) and `jetbrainsd` (`< 0.9.9728`, `CVE-2026-118697`), JetBrains IDEs (IntelliJ IDEA, PyCharm, PhpStorm, RubyMine, WebStorm, GoLand, Rider, CLion, DataGrip, RustRover, and DataSpell `< 2026.3` / `< 2026.2.4` / `< 2026.1.5.1` / `< 2025.3.6.2`, `CVE-2026-118696`), CPython (`< 3.15.1` / `< 3.14.9` / `< 3.13.17`, which also fix `CVE-2026-114583` and add the `ssl` SPKI denylist `CVE-2026-115557`), Go (`< 1.27.3` / `< 1.26.10`), Node.js (`< 26.12.1` / `< 24.22.1` / `< 22.23.4`), Electron (`< 45.0.0-beta.6` / `< 44.9.1` / `< 43.8.1` / `< 42.11.16`, `CVE-2026-115570`) and MongoDB Compass (`< 1.53.1`, `CVE-2026-115929`), Python `certifi` (`< 2026.10.19`) and `pip` (`< 26.2.2`), Rust `rustls-webpki` (`< 0.103.16`) and `webpki-roots` (`< 1.0.10`), Composer `ca-bundle` (`< 1.6.0` / `< 1.4.16`), and OpenJDK / Oracle JDK (`blocked.certs` fingerprint blocklists)

Update, 21 November 2026: pip now has its own CVE for the bundled certificates. On 20 November the Python Software Foundation CNA published CVE-2026-133949 (CVSS 4.0 9.3, critical): “pip prior to v26.2.2 the certifi bundled with pip contains the compromised eMudhra certificates.” Seth Larson announced it on Python’s security-announce list the same day, and Alan Coopersmith forwarded it to oss-security. The fixed version hasn’t changed: it’s still pip 26.2.2 (20 October), as described below, and 26.3 is the current release. The CVE’s fix reference is pypa/pip PR #14371, which upgraded the vendored certifi to 2026.10.18. The CVE adds one clarification: pip is not vulnerable when it runs on a Python that rejects the compromised intermediates (CPython 3.15.1, 3.14.9 or 3.13.17 and later, CVE-2026-115557). On older Pythons, upgrade pip with the hash-pinned wheel shown in the 23 October update so the upgrade download itself doesn’t depend on the bad chain. The GitHub Advisory Database only had an unreviewed record for the new CVE on 21 November (GHSA-jg88-vh4g-v698, no package attached). Scanners that key on reviewed advisories will flag the certifi advisory GHSA-6q48-6c7w-9gw2 but not pip’s vendored copy, so check pip --version directly in base images and CI runners.

Update, 31 October 2026: On 30 October (18:17 UTC and 20:24 UTC), NVD and the GitHub Advisory Database published three more developer-tooling advisories for the compromised eMudhra intermediate CA keys:

  • PyPA gh-action-pypi-publish Trusted Publishing and Sigstore bundle (GHSA-5xjx-3w67-w9x9, Critical, fixed in v1.14.3): Versions <= 1.14.2 of pypa/gh-action-pypi-publish bundled a certifi TLS trust store inside their container image that still trusted the compromised emSign root CA during Sigstore Digital Attestation and PyPI Trusted Publishing token exchange. Pin workflows to pypa/gh-action-pypi-publish@v1.14.3 (commit 7245906fb61fa33a13554f9d5fb856fe61758086 or floating @release/v1).
  • JetBrains background daemon jetbrainsd compiled-in trust store (CVE-2026-118697, CVSS 9.0 Critical): The JetBrains Toolbox App (< 3.9.1 and < 3.8.2) and JetBrains IDEs (< 2026.3 and < 2026.2.4) install a per-user background daemon named jetbrainsd that embeds its own trusted CA list separately from the bundled JetBrains Runtime (JBR), so updating JBR alone leaves jetbrainsd vulnerable to TLS interception with a forged eMudhra certificate. Updating any single JetBrains product that bundles jetbrainsd >= 0.9.9728 (such as Toolbox App 3.9.1 / 3.8.2 or IntelliJ IDEA 2026.2.4 / 2026.3) replaces the running per-user jetbrainsd daemon for all JetBrains apps on the machine.
  • JetBrains IDE embedded Chromium browser (JCEF) CRLSet updates (CVE-2026-118696, CVSS 8.0 High): In IntelliJ IDEA, PyCharm, PhpStorm, RubyMine, WebStorm, GoLand, Rider, CLion, DataGrip, RustRover, and DataSpell prior to the 2026.3, 2026.2.4, 2026.1.5.x, and 2025.3.x patch releases, the embedded JCEF browser did not fetch Chrome certificate revocation updates (CRLSet), leaving it trusting the revoked eMudhra intermediates. Note that in air-gapped or firewall-restricted environments that block access to Google’s update servers, JCEF cannot download the revocation list even after patching; on those networks, disable the embedded browser by adding -Dide.browser.jcef.enabled=false under Help | Edit Custom VM Options. IDEs on 2025.1 and earlier do not receive backports and must upgrade to a supported release line.

Update, 24 October 2026: On 24 October, the Python Security Response Team published CVE-2026-115557 (CVSS v4.0 9.4 Critical, oss-security/2026/10/24/5, python/cpython PR #160042 / issue #160040), documenting the defense-in-depth SubjectPublicKeyInfo (SPKI) denylist compiled directly into CPython’s C _ssl module (Modules/_ssl/distrusted_spki.h, shipped in Python 3.15.1, 3.14.9, and 3.13.17). During TLS chain verification, _cert_has_distrusted_spki() hashes each certificate’s DER-encoded SubjectPublicKeyInfo with EVP_sha256() and rejects the handshake if any certificate in the verified chain matches one of the eight compromised eMudhra intermediate public keys. Because the check matches the public key (SPKI) inside _ssl.c rather than an outer certificate fingerprint or a PEM bundle, it blocks both the emSign and Sectigo cross-signed intermediates regardless of SSLContext settings, outdated OS/container CA stores, or unpatched certifi virtualenvs. Separately, on 23 and 24 October, Electron published CVE-2026-115570 (GHSA-jr5w-w6x2-84p9, fixed in Electron 45.0.0-beta.6, 44.9.1, 43.8.1, and 42.11.16) and MongoDB Compass published CVE-2026-115929 (fixed in Compass 1.53.1, which updates its bundled Electron runtime to 44.9.1) to remove trust for the compromised eMudhra intermediates in Chromium’s bundled root store.

Update, 23 October 2026: On 22 October, the Python release team shipped expedited security releases Python 3.15.1, 3.14.9, and 3.13.17 (an exception for 3.13, which had already entered source-only security mode) to bundle pip 26.2.2 and certifi 2026.10.19 inside ensurepip and official macOS/Windows installers, and published direct SHA-256 wheel pinning instructions (pip-26.2.2-py3-none-any.whl#sha256=fd7f4dfa8190e014013b9f08f3e973f4e4c26ffd179a204895533a7254813a70) so existing virtual environments can upgrade pip without trusting the compromised eMudhra chain during the upgrade download itself. Alongside the CA fix, CPython disclosed CVE-2026-114583 (PSF-2026-45, PR #160098), a tarfile.tar_filter path-traversal bypass where a link member whose normalized name is . replaces the destination directory with a symlink and redirects subsequent extracted files outside the destination. Also on 22 October, eMudhra’s board announced that the company will exit its global SSL/TLS certificate business following the compromise of the eight intermediate CA keys.

Update, 22 October 2026: The underlying eMudhra incident is now tracked across runtimes as CVE-2026-111943 (Go and Rust rustls-webpki RUSTSEC-2026-0382) and CVE-2026-113812 (Mozilla::CA). On 20 and 21 October, emergency releases landed across Go (1.27.3 and 1.26.10, which require rebuilding compiled Go binaries), Node.js (26.12.1, 24.22.1, and 22.23.4), pip (26.2.2), rustls-webpki (0.103.16), Composer ca-bundle (1.6.0 and 1.4.16), and Java (27.0.1.0.2, 25.0.5.0.2, 21.0.13.0.2, 17.0.21.0.2, 11.0.33.0.2, and 8u511). In addition, on 21 October Sonatype Research demonstrated that Java’s blocked.certs SHA-256 certificate-fingerprint blocklist can be bypassed without the root CA private key by re-encoding an affected eMudhra intermediate certificate (replacing ECDSA s with n - s, or stripping the optional ASN.1 NULL parameter from the outer RSA signature AlgorithmIdentifier). See the cross-runtime table and Java bypass details added below.

If you use uv as a package installer, lockfile resolver, or CI bootstrap tool, the 20 October advisory is worth reading as a supply-chain issue, not just a certificate story. The trust boundary at stake is the HTTPS session uv uses to download package indexes, wheels, source distributions, and Python installs. Before 0.13.4, that connection trusted a vendored root bundle that still contained emSign ECC Root CA - G3, even after the associated intermediate keys had been reported compromised and revoked.

For AppSec teams, the abuse path is straightforward:

attacker holds one compromised intermediate key
  -> presents forged certificate for pypi.org, files.pythonhosted.org, or an internal index
  -> uv accepts the TLS chain because the bundled trust store still contains the emSign root
  -> attacker serves tampered package metadata or artifacts over an otherwise "valid" HTTPS session

No preinstall hook or maintainer-account takeover is required if the attacker can win the network path. That puts this in the same family of delivery-path integrity problems as our earlier coverage of apko and melange trusting the wrong APK proof and Go’s checksum trust gap around GOMODPROXY. The failure lives in what the tool decides to trust before it installs software.

Affected versions and what changed

The version boundary is clean:

uv < 0.13.4   affected
uv >= 0.13.4  fixed

The upstream advisory, package metadata, and 0.13.4 release all point to the same fix line. The important part is that uv did not ship a bespoke certificate parser bug. It inherited a stale trust anchor through its bundled Mozilla roots, then corrected that bundle one day after webpki-root-certs published 1.0.10 with the emSign removal.

The release commit for uv 0.13.4 is mostly version churn, but the real security change sits in the preceding dependency update:

name = "webpki-root-certs"
-version = "1.0.9"
+version = "1.0.10"

The linked webpki-roots release note is unusually direct:

Removed "emSign ECC Root CA - G3"

That is the trust decision that mattered.

Why vulnerable uv builds used the bad root by default

The CLI definition says the quiet part plainly. In crates/uv-cli/src/lib.rs, the --system-certs flag exists because the default is not the platform store:

/// Whether to load TLS certificates from the platform's native certificate store [env: UV_SYSTEM_CERTS=]
///
/// By default, uv uses bundled Mozilla root certificates, which improves portability and
/// performance (especially on macOS).
pub system_certs: bool,

The HTTP client builder wires that default into the request path. In crates/uv-client/src/base_client.rs, once uv chooses Rustls it decides between three certificate sources: explicit overrides, platform roots, or its vendored bundle.

let client_builder = if let Some(custom_certs) = custom_certs {
    client_builder.tls_certs_only(custom_certs)
} else if self.system_certs {
    client_builder
} else {
    client_builder.tls_certs_only(Certificates::webpki_roots().to_reqwest_certs())
};

And Certificates::webpki_roots() in crates/uv-client/src/tls.rs is only a thin wrapper around the vendored crate:

pub(crate) fn webpki_roots() -> Self {
    Self(webpki_root_certs::TLS_SERVER_ROOT_CERTS.to_vec())
}

That means the security story is not hidden in a corner case. For the default uv path, the vendored root list is the trust store. Updating webpki-root-certs changes what every HTTPS package fetch will accept.

Why this matters for package delivery

uv sits on several sensitive edges at once:

  • it resolves packages from PyPI and alternate indexes
  • it downloads wheels and source distributions
  • it is often bootstrapped into CI with pinned binaries or curl-based install steps
  • it is increasingly used as the default Python package tool inside container builds

If an attacker can impersonate a package host that uv is allowed to contact, they do not need to break your application. They need the package manager to accept the TLS session long enough to hand it different package contents or metadata.

That can affect:

  • uv pip install ...
  • uv sync
  • uv lock
  • uvx ...
  • Python downloads and tool installs that reuse the same HTTP client stack

Teams sometimes hear “certificate issue” and think “browser warning.” That framing is too weak here. This was a package-ingestion trust problem in a tool that many organizations use before code review, tests, or signature checks ever happen.

Custom certs and system certs are not a magic exemption

The advisory is careful on this point, and responders should be too.

If you already ran uv with --system-certs, the OS trust store rather than the vendored bundle decided whether the bad lineage was trusted. That can reduce exposure, but only if the system store had already distrusted the emSign line.

If you used SSL_CERT_FILE or SSL_CERT_DIR, uv treats those as a full replacement for its default roots. The code says so explicitly:

/// Returns `None` if neither variable is set to a non-empty value. An explicitly configured
/// file or directory always replaces the default certificate roots, even when it is missing,
/// inaccessible, or contains no valid certificates.
pub fn from_env() -> Option<Self> { ... }

So the response question is not just “Did we set custom certs?” It is “What exact roots did that file, directory, or operating system trust on 20 October?”

What to search for

Start by finding where uv is part of the build or bootstrap path:

rg -n 'astral\\.sh/uv|\\buvx?\\b|uv pip|uv sync|uv lock|UV_SYSTEM_CERTS|SSL_CERT_FILE|SSL_CERT_DIR' \
  .github Dockerfile docker-compose.yml compose.yml scripts .devcontainer .

Then check the actual binary or package version on runners and base images:

uv --version
python -m pip show uv 2>/dev/null || true

If you build containers or golden CI images, also search image definitions and install scripts for pinned uv versions below 0.13.4:

rg -n 'uv==0\\.|uv 0\\.|0\\.13\\.[0-3]|install\\.sh|astral-sh/uv/releases/download' \
  Dockerfile* .github scripts ci .

The scoping questions that matter are:

  1. did any workstation, runner, or image use uv below 0.13.4?
  2. did that system fetch packages through the default bundled roots rather than a known-good system store?
  3. could an attacker influence the network path to PyPI, an artifact mirror, or a private index during that period?

Remediation

Upgrade first:

  1. move every uv install path to 0.13.4 or later
  2. rebuild CI and developer base images that embed older uv binaries
  3. if you rely on custom trust roots, review the actual contents of SSL_CERT_FILE, SSL_CERT_DIR, or the system store instead of assuming the override made you safe

Then widen the lens. The uv advisory explicitly points out that this was not unique to one package. Other software that vendors CA bundles from projects like certifi or webpki-root-certs may have carried the same stale trust anchor. The Python security announcement for certifi went further and told operators to rebuild container images so the updated CA material actually lands on disk. The same operational advice makes sense here if uv is baked into your builder images.

Cross-runtime fixes and the Java blocked.certs fingerprint bypass (21 October update)

The eMudhra incident affected eight intermediate CA certificates generated during an April 2025 ceremony: six TLS intermediates (EM DV, OV, and EV TLS CA under G3B and G3C) and two code-signing intermediates, each existing in both an eMudhra emSign root form and a Sectigo AAA Certificate Services cross-signed form. Because non-browser HTTP clients and package managers rarely enforce online CRL or OCSP checks, language runtimes and registries had to ship code or bundle updates across 20 and 21 October:

Runtime / package toolAdvisory / CVEFixed versionHow the fix works
uvGHSA-hq85-5cpj-mr620.13.4Updates webpki-root-certs to 1.0.10, removing emSign ECC Root CA - G3
Python certifi, pip, and CPython (3.13 to 3.15)GHSA-6q48-6c7w-9gw2, CVE-2026-115557, CVE-2026-114583certifi 2026.10.19, pip 26.2.2, Python 3.15.1, 3.14.9, 3.13.17Rejects the eight intermediate SPKI SHA-256 digests directly in CPython Modules/_ssl/distrusted_spki.h (CVE-2026-115557), removes emSign ECC Root CA - G3 from certifi, upgrades bundled pip inside ensurepip, and fixes tarfile.tar_filter destination-link replacement (CVE-2026-114583)
Electron and MongoDB CompassCVE-2026-115570 (GHSA-jr5w-w6x2-84p9), CVE-2026-115929Electron 45.0.0-beta.6, 44.9.1, 43.8.1, 42.11.16; MongoDB Compass 1.53.1Distrusts the compromised eMudhra intermediates in Electron’s bundled TLS root store
pypa/gh-action-pypi-publishGHSA-5xjx-3w67-w9x91.14.3 (7245906fb6)Updates the bundled certifi CA store used by Sigstore Digital Attestations and PyPI Trusted Publishing
JetBrains Toolbox App, jetbrainsd, and JetBrains IDEsCVE-2026-118697, CVE-2026-118696Toolbox App 3.9.1, 3.8.2 (jetbrainsd 0.9.9728); IDEs 2026.3, 2026.2.4, 2026.1.5.1, 2025.3.6.2Updates the compiled-in CA list inside jetbrainsd (0.9.9728), updates bundled JBR trust stores, and enables Chrome CRLSet updates in the embedded JCEF browser
Rust rustls-webpki, webpki-roots, rustupRUSTSEC-2026-0381, 0382, 0383rustls-webpki 0.103.16, webpki-roots 1.0.10, rustup 1.29.2Rejects the eight intermediate SPKIs in rustls-webpki and drops the root from webpki-roots
Go (crypto/x509)CVE-2026-111943 (GO-2026-6809)1.27.3, 1.26.10Rejects chains containing any of the eight compromised public keys (requires rebuilding Go binaries)
Node.jsNode security release26.12.1, 24.22.1, 22.23.4Rejects the eight compromised keys and updates bundled roots to NSS 3.131.1
Composer ca-bundleUpstream release1.6.0, 1.4.16Distrusts the eight intermediates and refreshes the bundled root list
Perl Mozilla::CACVE-2026-11381220261020Updates the bundled Mozilla CA root store
OpenJDK / Oracle JDKOracle CPU (ops.java/emudhra)27.0.1.0.2, 25.0.5.0.2, 21.0.13.0.2, 17.0.21.0.2, 11.0.33.0.2, 8u511Updates lib/security/blocked.certs (blacklisted.certs on Java 8); see fingerprint-bypass caveat below

On 21 October 2026, Sonatype Research published a reproducible bypass showing why exact SHA-256 certificate-fingerprint blocklists like Java’s lib/security/blocked.certs are fragile when an attacker holds an intermediate CA’s private key.

Java’s blocked.certs matches the SHA-256 hash of the entire DER-encoded X.509 certificate (Certificate ::= SEQUENCE { tbsCertificate, signatureAlgorithm, signatureValue }). The CA’s signature covers only tbsCertificate, not the outer signatureAlgorithm wrapper or the encoding of signatureValue itself. Without touching tbsCertificate or needing the root CA’s private key, an attacker can mutate the outer bytes of a compromised eMudhra intermediate certificate so its SHA-256 fingerprint changes while the root signature still validates:

  • For ECDSA intermediates, an ECDSA signature ((r, s)) over a curve of order (n) has an equally valid twin ((r, n - s)) over the same tbsCertificate. Replacing (s) with (n - s) changes the DER bytes and produces a new SHA-256 certificate fingerprint that misses blocked.certs.
  • For RSA intermediates, omitting the optional ASN.1 NULL parameter from the outer signatureAlgorithm AlgorithmIdentifier (outside tbsCertificate) alters the outer DER bytes and the certificate’s SHA-256 fingerprint without invalidating the RSA signature over tbsCertificate.

For Java workloads that connect to external HTTPS endpoints or Maven repositories, do not rely solely on a hand-appended list of 16 SHA-256 fingerprints in blocked.certs. Either remove the affected roots (emSign ECC Root CA - G3 and, where unused, the cross-signing root) from the JVM’s cacerts truststore with keytool -delete, or enable revocation checking (-Dcom.sun.net.ssl.checkRevocation=true -Dcom.sun.security.enableCRLDP=true) alongside the patched JDK update.

What defenders should remember

The useful lesson in this incident is that package-manager trust does not begin at the artifact hash. It begins earlier, at the TLS session that decides which index page, wheel, or source distribution the tool will accept in the first place.

For uv, the fix was small: one dependency bump and a new release. The exposure was broader than that diff looks, because the old default trust store sat in front of every HTTPS package fetch. If your Python supply chain now depends on uv, this is the kind of issue that deserves the same attention as a malicious package publish. It changes what code your environment can be convinced to download and trust.

From research to remediation

Check whether this pattern exists in your codebase

Turn this research into a remediation workflow. Scan dependencies and package manifests for similar supply-chain risk, then prioritize fixes with reachability context.

References