DigiCert G5 Roots: Trust Store Readiness Checks
DigiCert issues from G5 roots by default on Nov 12, 2026. Check which Java, Node.js, Python, and OS trust stores include them, and fix the ones that don't.
Control Plane Labs Staff
Published November 7, 2026
DigiCert’s root strategy notice explains why the change is happening. From September 15, 2027, the Chrome Root Store will support only two DigiCert TLS roots, the two G5 roots. Certificates chaining to DigiCert Global Root G2 and G3 stop being trusted in Chrome on that date. To get customers there in time, DigiCert makes G5 the default for new orders, renewals, reissues, and duplicates on November 12, between 18:00 and 20:00 UTC.
For a public website that serves its full chain, this is a non-event for browsers. The migration guide says the G5 roots have been going into trust stores, including Microsoft’s, since 2021. The risk sits in the clients you run: API consumers, webhooks, payment and identity integrations, monitoring agents, build tools, and appliances that bring their own copy of the trusted roots. Those copies were frozen when the runtime or image was built, so an old enough one has never heard of G5.
What changes on November 12
DigiCert’s G5 migration and ICA selection guide lists the new default intermediates. For the DigiCert brand they’re DigiCert G5 TLS RSA4096 SHA384 2021 CA1 and DigiCert G5 TLS ECC SHA384 2021 CA1. GeoTrust, Thawte, RapidSSL, and Encryption Everywhere each get their own G5 RSA and ECC intermediates under the same two roots. If you see “G5” in your issuer name after the switch, the chain ends at a G5 root.
The guide also lays out the timeline for staying on the old roots:
| Date | What happens to G2/G3 issuance |
|---|---|
| November 12, 2026 | G5 becomes the default; G2 and G3 stay available if you select them explicitly |
| February 28, 2027 | G2/G3 certificates are shortened so they expire by September 14, 2027 |
| June 8, 2027 | G2/G3 options are removed from accounts without an approved exception |
| September 15, 2027 | Chrome stops trusting certificates from the Global G2 and G3 hierarchies |
Staying on G2 or G3 buys you months, not years. Use that option only for a client you can’t fix before your next renewal, and track it as a dated exception.
Automation follows the default unless it says otherwise. The guide says API orders without a ca_cert_id use the account’s default intermediate, and so do ACME directory URLs without an ICA configured. ACME URLs that already have an intermediate selected keep it after November 12. If you use cert-manager, Certbot, or another ACME client against DigiCert, check the directory URL configuration in CertCentral to find out which path your next renewal takes.
Our test: which trust stores include the G5 roots
DigiCert runs demo sites for both roots: the RSA4096 G5 demo and an ECC P384 equivalent, linked from its trusted root certificates page. We pointed common clients at both on November 7, 2026, and then checked the source of each runtime’s bundled trust store to find the first release that includes DigiCert TLS RSA4096 Root G5.
| Client | Result against the G5 demo sites | First release with the G5 roots |
|---|---|---|
curl with Ubuntu 26.04 ca-certificates 20260223 |
Pass | Any current distro package |
| Node.js 22.23.2 bundled store | Pass | 14.21.2, 16.19.0, 18.13.0, 19.2.0 |
OpenJDK 25.0.3 (Debian cacerts) |
Pass | 21.0.2, 17.0.10, 11.0.22, 8u402 |
| Python with certifi 2022.6.15 | Pass | certifi 2022.6.15 |
| Python with certifi 2022.5.18.1 | Fail: CERTIFICATE_VERIFY_FAILED |
Not included |
| openssl s_client with certifi 2022.5.18.1 | Fail: verify code 19 | Not included |
The Node.js rows come from src/node_root_certs.h in each release tag. The root first appears in Node.js 18.13.0 (January 5, 2023) and in 16.19.0 and 14.21.2 (December 13, 2022). It’s absent from 18.12.0, 16.18.0, and 14.21.1. Every Node.js 20 and later release includes it.
For Java, the roots arrived in OpenJDK change 8318759, “Add four DigiCert root certificates,” committed in November 2023 and backported. We checked the cacerts source directory at each update tag: the G5 file is present in 21.0.2, 17.0.10, 11.0.22, and 8u402, and missing from 21.0.1, 17.0.9, 11.0.21, and 8u401. Note that many Linux packages of OpenJDK replace the bundled cacerts with the distro’s store, as Debian and Ubuntu do. On those systems, the distro ca-certificates package matters more than the JDK version.
For Python, the roots first appear in certifi 2022.6.15, uploaded June 15, 2022. 2022.5.18.1 doesn’t have them. The failure with the old bundle reads as “self-signed certificate in certificate chain,” because the demo site sends the G5 root along with the intermediate and the old bundle has no matching trusted root. The full results are in our test dataset. That error can send you looking for a server misconfiguration when the real problem is the client’s trust store.
The roots were accepted into Mozilla’s store through bug 1764392, and most Linux distributions build ca-certificates from that store. Any image built in the last three years from a supported distro release should be fine. Images built from end-of-life releases, or images that never run a package update, are the ones to check.
Check every client you run
Start with the clients that call DigiCert-protected endpoints: your own APIs if you buy DigiCert certificates, and third-party APIs whose certificates come from DigiCert. Our week 2026-45 recap found 56 of 102 widely used SaaS, finance, and developer domains on DigiCert, so most fleets call at least one. Use the TLS inspector to see which CA issues a given endpoint’s certificate.
The fastest test is to run each client against the demo sites from the place it actually runs, such as a pod, a CI runner, or an appliance shell:
for h in digicert-tls-rsa4096-root-g5.chain-demos.digicert.com \
digicert-tls-ecc-p384-root-g5.chain-demos.digicert.com; do
curl -sS -o /dev/null -w "%{http_code} $h\n" "https://$h/"
done
curl tests the system store. Runtimes with their own store need their own test:
# Python: whichever bundle requests or urllib actually uses
python3 -c 'import certifi;print(certifi.__version__, certifi.where())'
grep -c "DigiCert TLS RSA4096 Root G5" "$(python3 -c 'import certifi;print(certifi.where())')"
# Java: the cacerts the running JVM loads
keytool -list -cacerts -storepass changeit | grep -i "root_g5\|rootg5"
# Debian/Ubuntu/Alpine system store
ls /etc/ssl/certs | grep -i "G5"
For Node.js, parse the bundled store, as we did:
node -e 'const t=require("tls"),c=require("crypto");for(const p of t.rootCertificates){const s=new c.X509Certificate(p).subject;if(s.includes("Root G5"))console.log(s.split("\n").pop())}'
On Node.js 22.23.2 that prints both CN=DigiCert TLS ECC P384 Root G5 and CN=DigiCert TLS RSA4096 Root G5.
Look beyond the runtime too. Python apps often carry their own certifi through a lockfile pin that hasn’t moved in years. Java apps sometimes ship a custom truststore file with -Djavax.net.ssl.trustStore, which overrides the JVM’s cacerts entirely. Go binaries use the system store on Linux, so a scratch or distroless image with an old CA bundle copied in at build time behaves like that old bundle. Appliances, load balancers doing upstream TLS, and IoT firmware keep their own lists, and only the vendor can update them.
Find pinned intermediates
DigiCert’s notice tells customers to stop pinning root and intermediate certificates. A client that trusts only “DigiCert Global G2 TLS RSA SHA256 2020 CA1” will reject every certificate from a G5 intermediate, even with the G5 roots installed. Search your code and config for the old intermediate names and their fingerprints:
grep -rIl -E "DigiCert Global G2 TLS RSA SHA256 2020 CA1|DigiCert Global G3 TLS ECC SHA384 2020 CA1|GeoTrust TLS RSA CA G1|Thawte TLS RSA CA G1|DigiCert EV RSA CA G2" .
grep -rIl -E "BEGIN CERTIFICATE" --include="*.pem" --include="*.crt" --include="*.yaml" . | head -50
The second search finds embedded certificate bundles, which you then inspect one by one with openssl x509 -noout -subject -issuer. Kubernetes manifests deserve a look: caBundle fields on webhooks and APIServices usually hold private CAs, but some teams paste public chains into ConfigMaps for egress clients. Mobile apps with certificate pinning are the hardest case, because an old app version in the field can’t be updated from the server side. If you pin, pin a key you control or include the G5 intermediates’ keys in the pin set before your backend renews.
Fix the clients that fail
In order of preference:
- Update the trust store. Upgrade the runtime to a release in the table above, run the distro’s
ca-certificatesupdate and rebuild the image, or bump certifi. This is the only fix that lasts past 2027. - Add the G5 roots to a managed store. Download DigiCert TLS RSA4096 Root G5 and DigiCert TLS ECC P384 Root G5 and import them. Verify the SHA-256 fingerprint against DigiCert’s root page before you trust the file. For the RSA root it’s
37:1A:00:DC:05:33:B3:72:1A:7E:EB:40:E8:41:9E:70:79:9D:2B:0A:0F:2C:1D:80:69:31:65:F7:CE:C4:AD:75. For Node.js,NODE_EXTRA_CA_CERTSadds a PEM file to the bundled store at startup. - Serve the cross-signed root. If you run the server and can’t reach every client, DigiCert’s cross-signed root tutorial shows how to append a cross-certificate to the G5 intermediate file. The migration guide recommends the G2 cross-sign for RSA certificates and the G3 cross-sign for ECC certificates. Clients that trust G2 or G3 then build a path through the cross-sign. This helps only until the old roots stop being trusted, so treat it as a bridge.
- Request G2 or G3 issuance for one more renewal. It’s the last resort, and the timeline above caps how long it works.
After any fix, rerun the demo-site test from the same place the client runs. Then check your own endpoint the day after your first G5 renewal, with the TLS inspector or openssl s_client -showcerts, to confirm the server sends the G5 intermediate and not just the leaf certificate.
A note on client authentication
The same notice has a second deadline that catches different systems. On March 1, 2027, DigiCert removes the clientAuth extended key usage from public TLS certificates on all four roots. If a partner integration uses one of your public DigiCert certificates as a client certificate for mTLS, that breaks at your first renewal after March 1, whichever root it chains to. The fix there is a private CA for client identities. Chrome’s root program policy is what drives that change across all public CAs. Our certificate lifetime checker shows when each of your certificates last renewed, which tells you when the first G5 and the first serverAuth-only certificates will arrive.
Frequently asked questions
When does DigiCert switch to the G5 roots?+
Which Java versions trust the DigiCert G5 roots?+
Which Node.js versions include the DigiCert G5 roots?+
Which certifi version includes the DigiCert G5 roots?+
How do I test whether a client trusts the G5 roots?+
Can I keep using DigiCert Global Root G2 or G3?+
What does the G5 cross-signed root do?+
Tags: #tls, #pki, #digicert, #trust-store, #java, #nodejs, #python, #certificates