CVE-2026-32280: Go crypto/x509 DoS Vulnerability

CVE-2026-32280 Overview

CVE-2026-32280 is a denial of service vulnerability in the Go programming language's crypto/x509 package. During certificate chain building, the amount of work performed is not correctly limited when a large number of intermediate certificates are passed in VerifyOptions.Intermediates. This resource exhaustion vulnerability affects both direct users of crypto/x509 and users of crypto/tls, potentially causing service unavailability for applications that process untrusted certificate chains.

Critical Impact
Applications using Go's crypto/x509 or crypto/tls packages for certificate verification may become unresponsive when processing specially crafted certificate chains containing an excessive number of intermediate certificates, leading to denial of service conditions.

Affected Products

Go crypto/x509 package
Go crypto/tls package
Applications built with Go that perform certificate chain validation

Discovery Timeline

2026-04-08 - CVE CVE-2026-32280 published to NVD
2026-04-08 - Last updated in NVD database

Technical Details for CVE-2026-32280

Vulnerability Analysis

This vulnerability (classified as CWE-770: Allocation of Resources Without Limits or Throttling) exists in Go's certificate chain building logic within the crypto/x509 package. When verifying a certificate chain, the VerifyOptions structure allows specifying intermediate certificates through the Intermediates field. The vulnerable code path does not properly bound the computational work performed when processing a large number of these intermediate certificates.

An attacker can exploit this by providing a certificate verification request with an excessive number of intermediate certificates, causing the chain building algorithm to consume disproportionate CPU and memory resources. This can render the affected service unresponsive, impacting availability for legitimate users.

Root Cause

The root cause is improper resource limitation in the certificate chain building algorithm. The crypto/x509 package's chain verification logic iterates through and processes intermediate certificates without adequate bounds checking on the total work performed. This creates an algorithmic complexity issue where the processing time grows significantly with the number of intermediate certificates provided, allowing attackers to amplify resource consumption through carefully crafted inputs.

Attack Vector

The attack vector is network-based, requiring no authentication or user interaction. An attacker can trigger this vulnerability by:

Establishing a TLS connection to a vulnerable Go service and presenting a certificate with an excessive number of intermediates
Sending data to an application that performs certificate verification on untrusted input with a malicious certificate chain
Exploiting any code path that calls certificate verification methods with attacker-controlled VerifyOptions.Intermediates

The vulnerability is particularly concerning for public-facing services that accept client certificates or perform certificate validation on external data.

Detection Methods for CVE-2026-32280

Indicators of Compromise

Unusual CPU spikes during TLS handshakes or certificate verification operations
Memory consumption increases in Go applications performing certificate validation
Service unresponsiveness or timeouts during certificate chain verification
Log entries indicating slow or failed certificate verification operations

Detection Strategies

Monitor application performance metrics for abnormal resource consumption during TLS operations
Implement application-level logging for certificate verification duration and intermediate certificate counts
Deploy network intrusion detection rules to identify TLS connections with unusually large certificate chains
Use Go runtime profiling to detect goroutines stuck in certificate verification loops

Monitoring Recommendations

Set up alerts for CPU and memory utilization thresholds on services performing certificate verification
Monitor TLS handshake duration metrics for anomalous increases
Track the number of certificate verification operations and their completion times
Implement circuit breakers or rate limiting on certificate verification code paths

How to Mitigate CVE-2026-32280

Immediate Actions Required

Update Go installations to patched versions as soon as available
Audit applications for usage of crypto/x509.Certificate.Verify() or crypto/tls with untrusted certificate inputs
Consider implementing application-level limits on the number of intermediate certificates accepted
Deploy monitoring for resource exhaustion patterns in certificate processing paths

Patch Information

The Go team has addressed this vulnerability through Code Review CL 758320. Security updates have been announced via the Golang Announcement Group. Additional details are available in the Go.dev Issue Tracker and the Go.dev Vulnerability Advisory GO-2026-4947.

Workarounds

Implement input validation to limit the number of intermediate certificates accepted before calling verification
Add timeouts around certificate verification operations to prevent indefinite resource consumption
Use a reverse proxy or load balancer with TLS termination that enforces certificate chain size limits
Consider isolating certificate verification operations in separate processes with resource limits

bash

# Configuration example - Set resource limits for Go applications
# Using cgroups v2 to limit CPU and memory for the application
# Create a cgroup for the application
mkdir -p /sys/fs/cgroup/go-app

# Set CPU quota (50% of one core)
echo "50000 100000" > /sys/fs/cgroup/go-app/cpu.max

# Set memory limit (512MB)
echo "536870912" > /sys/fs/cgroup/go-app/memory.max

# Run the Go application within the cgroup
cgexec -g cpu,memory:go-app ./your-go-application