CVE-2026-32280: 
Go vulnerability analysis and mitigation

CVE-2026-32280 is a denial-of-service vulnerability in Go's crypto/x509 and crypto/tls standard library packages caused by unbounded work during certificate chain building. When a large number of intermediate certificates are passed via VerifyOptions.Intermediates, the chain-building algorithm does not correctly limit the amount of computation performed, leading to excessive CPU consumption. The vulnerability affects Go versions prior to 1.25.9 and versions 1.26.0 through 1.26.2. It was published on April 8, 2026, and carries a CVSS v3.1 base score of 7.5 (High) (GitHub Advisory, pkg.go.dev).

The root cause is classified as CWE-770 (Allocation of Resources Without Limits or Throttling). During X.509 certificate chain building, the Go runtime iterates over intermediate certificates supplied in VerifyOptions.Intermediates without imposing an upper bound on the computational work performed. An unauthenticated remote attacker can supply a crafted TLS handshake or certificate verification request containing a large number of intermediate certificates, triggering exponential or otherwise unbounded processing. This affects both applications directly calling crypto/x509 certificate verification APIs and any application using crypto/tls for TLS connections, since TLS relies on crypto/x509 for chain validation. The fix is tracked under Go issue #78282 and patch CL 758320 (go.dev CL, pkg.go.dev).

Successful exploitation results in a high-availability impact — an attacker can cause the affected Go process to consume excessive CPU resources, potentially rendering the service unresponsive or causing a complete denial of service. There is no confidentiality or integrity impact. The vulnerability is particularly significant for internet-facing services that accept TLS connections or perform certificate verification on untrusted input, including web servers, API gateways, and any Go application using crypto/tls. Downstream products incorporating Go's standard library — including IBM Instana Observability, IBM App Connect Enterprise, and various Linux distribution packages — are also affected (GitHub Advisory, IBM Advisory).

No public proof-of-concept exploit code is known to exist, and there is no evidence of in-the-wild exploitation at this time (GitHub Advisory). The vulnerability is exploitable remotely without authentication or user interaction, lowering the barrier for potential abuse. The EPSS score is approximately 0.007% (very low probability of exploitation in the next 30 days). The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. No specific threat actor attribution has been reported.

1. Reconnaissance: Identify internet-facing services built with Go (versions < 1.25.9 or 1.26.0–1.26.1) that accept TLS connections or perform X.509 certificate verification, using tools like Shodan, Censys, or banner grabbing.
2. Craft malicious certificate chain: Generate a large set of intermediate X.509 certificates (e.g., hundreds or thousands) using tools such as OpenSSL or custom Go code. These certificates do not need to be trusted — they only need to be syntactically valid.
3. Deliver certificates to target: Initiate a TLS handshake with the target service and present the crafted certificate chain, or supply the certificates via an API endpoint that triggers x509.Certificate.Verify() with a populated VerifyOptions.Intermediates pool.
4. Trigger unbounded computation: The vulnerable chain-building logic processes the large intermediate set without throttling, causing the server's CPU to spike and the service to become unresponsive or crash.
5. Sustain denial of service: Repeat requests to maintain the DoS condition, as each new connection or verification request re-triggers the expensive computation (pkg.go.dev, go.dev CL).

• Network: Unusual volume of TLS handshake attempts from a single or small set of source IPs; connections presenting abnormally large certificate chains (hundreds of intermediate certificates in a single handshake).
• Process/System: Sustained high CPU utilization on Go-based service processes (e.g., near 100% CPU on a single core) without a corresponding increase in legitimate traffic; service timeouts or unresponsiveness during certificate verification operations.
• Logs: Application logs showing repeated or slow certificate verification operations; TLS handshake errors or timeouts logged in server access/error logs; Go runtime panics or OOM-adjacent errors in application logs during certificate chain processing.

The Go project has released fixed versions addressing this vulnerability: Go 1.25.9 and Go 1.26.2. All users of crypto/x509 or crypto/tls should upgrade to one of these versions immediately. No configuration-based workaround is available for the underlying issue; upgrading is the only reliable remediation. Downstream consumers — including IBM Instana Observability, IBM App Connect Enterprise, Red Hat products, openSUSE, Amazon Linux, and others — should apply their respective vendor-provided updates (go.dev CL, pkg.go.dev, IBM Advisory).

The Go team disclosed the vulnerability via the golang-announce mailing list and published a fix through standard Go release channels (golang-announce). The vulnerability was also disclosed on the oss-security mailing list. Multiple Linux distributions (Red Hat, openSUSE, Amazon Linux, AlmaLinux, Rocky Linux) and cloud providers (AWS, Google Cloud) have issued advisories and updated packages. Community reaction has been measured, consistent with a medium-severity DoS issue with no known active exploitation.