Handshake messages

CVE-2026-56862 is a denial-of-service vulnerability in Go's standard library crypto/tls package. In TLS 1.3, a KeyUpdate message instructs the peer to derive a fresh set of traffic keys — an intentionally expensive cryptographic operation. Go's implementation treated every KeyUpdate as "state-advancing" and imposed no rate limit on how many a remote peer could send, even after the handshake was already complete. A malicious client can open a single TLS 1.3 connection and flood it with KeyUpdate messages, pinning a server goroutine to continuous HKDF-Expand-Label derivations and consuming CPU indefinitely. Affected versions span every supported Go release branch: anything before go1.25.13, go1.26.0 through go1.26.5, and go1.27.0 through go1.27.0-rc.2. The fix (go1.25.13, go1.26.6, go1.27.0-rc.3) bounds how often rekeying is honored.

The vendor's CVSS 7.5 HIGH rating is technically correct on paper — the vector is unauthenticated, network-reachable, low-complexity, and availability-impacting. But in practice it overstates the risk for most enterprise fleets. First, this is availability-only: no confidentiality leak, no integrity compromise, no code execution. Second, the dominant deployment pattern for Go services in production puts them behind a TLS-terminating reverse proxy (nginx, Envoy, HAProxy, AWS ALB/NLB, GCP Cloud Load Balancer), meaning the Go process never sees raw TLS records and is completely shielded. Third, the DoS is connection-scoped — an attacker must maintain active connections to sustain the CPU burn, and standard connection-timeout and concurrency-limit configurations bound the blast radius. Ubuntu's security team independently downgraded this to Medium priority. noisgate agrees: for most enterprises, this is a MEDIUM.

1. Place Go services behind a TLS-terminating reverse proxy — If the Go process doesn't handle raw TLS, this CVE is completely neutralized. Deploy nginx, Envoy, HAProxy, or a cloud LB in front of any directly-exposed Go TLS endpoint. This is the single most effective control and should be prioritized as a noisgate remediation SLA item within the 365-day MEDIUM window, or immediately for any internet-facing Go TLS services.
2. Set connection timeouts and concurrency limits — Configure http.Server.ReadTimeout, WriteTimeout, and IdleTimeout (e.g., 60s each) and use http.Server.MaxHeaderBytes or golang.org/x/net/netutil.LimitListener to cap concurrent connections. This bounds the CPU burn duration and attacker resource commitment. Deploy within the remediation window.
3. Upgrade Go toolchain and rebuild affected binaries — Update to go1.25.13+, go1.26.6+, or go1.27.0-rc.3+ and recompile all affected services. This is the definitive fix. For the MEDIUM verdict, the noisgate remediation SLA gives 365 days, but prioritize internet-facing and high-value services (Kubernetes components, API gateways) within 90 days.
4. Monitor Go process CPU utilization — Alert on sustained CPU spikes (>90% for >60s) on Go TLS-serving processes via Prometheus, Datadog, or your APM stack. This provides detection-in-depth while patching rolls out. Configure immediately as an observability hygiene item.
5. Enforce mTLS where feasible — Requiring client certificates eliminates unauthenticated attackers from the threat model. This is already standard in service meshes (Istio, Linkerd) and Kubernetes internal communication. Verify enforcement on any Go service that terminates TLS directly.

Run this script on any host where Go binaries are deployed or the Go toolchain is installed. Execute as any user with read access to the target binaries: bash check_cve_2026_56862.sh [/path/to/go-binary]. If no argument is given, it checks the system Go toolchain version. No elevated privileges required.

#!/usr/bin/env bash
# check_cve_2026_56862.sh — Detect Go crypto/tls KeyUpdate DoS (CVE-2026-56862)
# Usage: bash check_cve_2026_56862.sh [/path/to/go-binary]
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN

set -euo pipefail

parse_go_version() {
  local raw="$1"
  # Extract version like go1.25.13 or go1.26.6
  local ver
  ver=$(echo "$raw" | grep -oP 'go1\.\d+\.\d+' | head -1)
  if [[ -z "$ver" ]]; then
    ver=$(echo "$raw" | grep -oP 'go1\.\d+' | head -1)
    if [[ -n "$ver" ]]; then ver="${ver}.0"; fi
  fi
  echo "$ver"
}

check_version() {
  local ver="$1"
  local major minor patch
  major=$(echo "$ver" | sed 's/go//' | cut -d. -f1)
  minor=$(echo "$ver" | cut -d. -f2)
  patch=$(echo "$ver" | cut -d. -f3)
  patch=${patch:-0}

  # go1.25.x: fixed in 1.25.13
  if [[ "$minor" -le 25 ]]; then
    if [[ "$minor" -lt 25 ]]; then
      echo "VULNERABLE"
    elif [[ "$patch" -lt 13 ]]; then
      echo "VULNERABLE"
    else
      echo "PATCHED"
    fi
  # go1.26.x: fixed in 1.26.6
  elif [[ "$minor" -eq 26 ]]; then
    if [[ "$patch" -lt 6 ]]; then
      echo "VULNERABLE"
    else
      echo "PATCHED"
    fi
  # go1.27.x: fixed in 1.27.0-rc.3 (treat any 1.27.0+ release as patched for simplicity)
  elif [[ "$minor" -ge 27 ]]; then
    echo "PATCHED"
  else
    echo "UNKNOWN"
  fi
}

if [[ $# -ge 1 ]]; then
  TARGET="$1"
  if [[ ! -f "$TARGET" ]]; then
    echo "UNKNOWN — file not found: $TARGET"
    exit 2
  fi
  RAW=$(go version "$TARGET" 2>/dev/null || true)
  if [[ -z "$RAW" ]]; then
    echo "UNKNOWN — could not determine Go version for $TARGET (not a Go binary or 'go' not in PATH)"
    exit 2
  fi
else
  RAW=$(go version 2>/dev/null || true)
  if [[ -z "$RAW" ]]; then
    echo "UNKNOWN — Go toolchain not found in PATH"
    exit 2
  fi
fi

VER=$(parse_go_version "$RAW")
if [[ -z "$VER" ]]; then
  echo "UNKNOWN — could not parse Go version from: $RAW"
  exit 2
fi

RESULT=$(check_version "$VER")
echo "$RESULT — $RAW (parsed: $VER)"

case "$RESULT" in
  PATCHED)    exit 0 ;;
  VULNERABLE) exit 1 ;;
  *)          exit 2 ;;
esac

1. Go Vulnerability Database — GO-2026-6090
2. Go Issue #80528 — Handshake messages bypass non-advancing record limit
3. KrakenD Security Advisory — CVE-2026-56862
4. Ubuntu Security — CVE-2026-56862
5. Red Hat Advisory — RHSA-2026:67975
6. Strix AI — CVE-2026-56862 Detail
7. NVD — CVE-2026-56862