Go 1.27.4 and 1.26.11 shipped on November 10 with twelve security fixes. Eleven stop a malicious package from running code while your CI builds it, and one stops an HTTP server crash. What the 9.8 score means, who needs to act, and how to upgrade.
What Shipped on November 10
On November 10, 2026, the Go team released Go 1.27.4 and 1.26.11, the two lines it currently supports. Together they carry twelve security fixes. Eleven are in the toolchain, meaning the go command, cgo, the compiler and the linker, and each of those closes a way for a malicious package to run code on the machine that builds it. The twelfth is in net/http and stops a crash in some HTTP/1 servers.
One of the eleven, CVE-2026-97040, started circulating this week with a critical 9.8 score attached. That number needs context, and most of the context is reassuring. Programs that are already built and running are not touched by the toolchain bugs at all. The risk sits with the build machine, and only when it compiles code that someone has deliberately poisoned. Neither CISA's catalog of exploited vulnerabilities nor the Go advisories point to any attacks so far, and the fixed toolchains have been on go.dev, Docker Hub and GitHub's setup-go for a week. For most teams the fix is a version bump in a Dockerfile or a workflow file.
go version # the toolchain on this machine
go version ./myapp # the Go version a binary was built with
What the 9.8 Actually Means
The Go project publishes its advisories without a severity score. The 9.8 comes from CISA's enrichment of the NVD record, added on November 16, and it scores the bug as if it could be exploited over the network with no user involved. CISA gave nine of the other toolchain bugs 8.8 and the pkg-config one 8.3. CISA's own vectors explain the gap. The 8.8 scores count building the package as a step a user has to take, and the 9.8 does not. Ubuntu rates CVE-2026-97040 as medium priority, and Debian is not issuing an urgent security advisory for the Go packages in its stable releases.
What separates the ratings is one precondition. Somebody has to build code that contains the malicious package. In practice that means a dependency you pulled in, a compromised release of a module you already use, or a tool you install with go install. No request sent to a running service can trigger any of the eleven.
That still matters, because a build machine usually holds the keys to everything else, from deploy credentials to registry tokens and signing keys. The npm compromise we covered in August showed what a poisoned dependency does on a build host full of credentials. So this is a supply chain risk to close calmly this week, and not an emergency on every server you run.
| Date | What happened |
|---|---|
| October 26, 2026 | Go issue 82570 created for the .syso bug |
| November 10, 2026 | Go 1.27.4 and 1.26.11 released with all twelve fixes |
| November 11, 2026 | The CVE records published, with no severity score |
| November 16, 2026 | CISA added its 9.8 and 8.8 scores to the NVD records |
| November 18, 2026 | No entry in CISA's exploited vulnerabilities catalog |
Why Building Go Code Is Not Supposed to Run It
Go makes a promise that npm and pip do not. Building a Go package should never execute anything its author wrote. There are no install scripts and no setup.py, and the Go team treats any way around that rule as a security bug.
The weak spot has always been cgo, the bridge that lets Go call C. A package that uses cgo can pass flags to the system's C compiler and linker, and those tools can do far more than compile. In 2018, CVE-2018-6574 showed that a package could load a compiler plugin through those flags during go get, and Go 1.9.4 and 1.8.7 answered with an allowlist of the flags a package may pass. The same class came back in June 2023 with CVE-2023-29402, CVE-2023-29404 and CVE-2023-29405.
All eleven of this month's toolchain fixes are new ways past that allowlist. They come from tracing what GCC, Clang, GNU ld and the Apple linker actually do with the arguments the allowlist lets through, and from file types the linker trusted too readily. RyotaK of GMO Flatt Security reported CVE-2026-97040 and CVE-2026-97041, and Ali Sherif reported the macOS linker bug.
The Twelve Fixes
| CVE | What was wrong | Where it applies |
|---|---|---|
| CVE-2026-97040 | A .syso file disguised as a Go object smuggled linker flags past validation | Any platform |
| CVE-2026-97038 | .syso files and library inputs could carry linker scripts or embedded linker options | Any platform |
| CVE-2026-97043 | Escaped quotes in cgo_ldflag directives let disallowed flags through | Any platform |
| CVE-2026-97041 | Commas in go:cgo_* directives injected flags into the external linker | ELF platforms such as Linux |
| CVE-2026-97042 | Library names were checked by their first character only, and DLL names in PE objects not at all | Windows for the DLL part |
| CVE-2026-97037 | Split -Wl, flags handed linker scripts to the host linker | Host linker, GNU ld in particular |
| CVE-2026-97039 | #cgo pkg-config directives could load untrusted .pc files | Builds that use pkg-config |
| CVE-2026-97033 | --sysroot, -target, -isysroot and -x pointed the compiler at attacker files | GCC and Clang |
| CVE-2026-97034 | GCC could load spec files from attacker-controlled directories | GCC |
| CVE-2026-97035 | Clang -gen-* and GCC -gnat* flags wrote files or confused flag parsing | GCC and Clang |
| CVE-2026-97036 | -l to_library loaded an arbitrary plugin into the Apple linker | macOS |
| CVE-2026-97054 | A MaxBytesReader header race could crash an HTTP/1 server | Programs using net/http |
The headline bug works like this. A .syso file is a precompiled object that Go links into a package as it is. The linker recognised the real object formats (ELF, Mach-O, PE and XCOFF) and treated anything else as a Go compiler object. A file that merely started with the Go object header was therefore read as one, and the cgo directives hidden inside it went to the external linker without passing through the allowlist. The fixed linker rejects any .syso file that is not a real host object.
Who Needs to Act
The toolchain bugs matter wherever a machine builds code that nobody on the team has read line by line, and that is most build machines.
- CI pipelines come first. Every go build compiles the whole dependency tree, so one poisoned module anywhere in go.sum is enough, and a runner that holds production secrets is the one worth protecting.
- Developer laptops count too, whenever someone runs go install or go run on a third-party tool at a version tag.
- Every one of these attacks goes through the external C compiler or linker. Most need cgo, and the .syso fix also stops an unrecognised .syso file from forcing the external linker in an otherwise pure Go build. A build image with no C toolchain is a smaller target, but it does not replace the upgrade.
The net/http fix is the reverse case. It protects running services, and it only reaches them when the binary is rebuilt with the new Go and deployed. An HTTP/1 server that uses MaxBytesReader or MaxBytesHandler can crash with a runtime panic if a handler reads the request body while the response headers are being written. CISA scored it 5.9. It needs that particular concurrent pattern, but a crash loop on a public API is an unpleasant way to discover you had it.
The handlers to look at are those that read the request body in one goroutine while another writes the response, as streaming endpoints and small proxies sometimes do. Go tools you run but do not build yourself, from exporters to command line utilities, are their vendors' call. The crash only affects programs that serve HTTP/1 with MaxBytesReader, so watch for their next releases instead of rebuilding them by hand.
Checking Your Pipelines and Code
Start with the Go versions your builds really use, which are often not the one on your laptop.
grep -rn "golang:" --include="Dockerfile*" . 2>/dev/null
grep -rn "go-version" .github/workflows/ .gitlab-ci.yml 2>/dev/null
grep -n "^toolchain" go.mod
Then see which dependencies use cgo or ship .syso files. Those are the packages the toolchain bugs run through, and for most web services the list is short. On Linux the first list also shows standard library packages such as net and os/user, and they are not the concern.
go list -deps -f '{{if .CgoFiles}}{{.ImportPath}}{{end}}' ./...
go list -deps -f '{{if .SysoFiles}}{{.ImportPath}} {{.SysoFiles}}{{end}}' ./...
Legitimate .syso files are real object files, usually Windows resources or prebuilt C code, in the COFF, ELF or Mach-O formats. A .syso that begins with the Go object header is exactly the disguise behind CVE-2026-97040, and the loop below lists any in your module cache. It only catches that one trick out of eleven, so treat it as a spot check, not a reason to delay the upgrade.
find "$(go env GOMODCACHE)" -name '*.syso' | while read -r f; do
head -c 9 "$f" | grep -q "go object" && echo "suspicious: $f"
done
For the net/http issue, govulncheck reports it if your code reaches the affected functions, judged against the Go version you build with.
go install golang.org/x/vuln/cmd/govulncheck@latest
govulncheck ./...
Upgrading
The fixed releases are already wherever builds usually get Go from. The official Docker images carry 1.27.4 and 1.26.11 tags, and the version manifest that GitHub's setup-go action reads lists both.
FROM golang:1.27.4 AS build
# GitHub Actions
- uses: actions/setup-go@v7
with:
go-version: "1.27.4"
# GitLab CI
build:
image: golang:1.27.4
The go.mod file can pin the toolchain as well. Running go get toolchain@go1.27.4 writes a toolchain line, and the go command then fetches and uses that release whenever a build starts with an older one. The exception is a machine where GOTOOLCHAIN is set to local, which some Linux distributions do.
Distribution packages lag behind, as they usually do with Go. Debian's unstable branch has 1.26.11 and 1.27.4, while its stable releases ship Go 1.19 in bookworm and 1.24 in trixie, lines the Go project no longer supports. Ubuntu's tracker lists every Go package as still awaiting triage. For building production code, the releases on go.dev and the official images are the dependable source.
Go 1.25 and older get none of these fixes, because each Go release is supported only until two newer major releases are out. A project still on 1.25 should move to 1.26.11 at the very least.
After the toolchain, rebuild and redeploy. A Go binary carries its own copy of the standard library, so the net/http fix reaches a service only when it is rebuilt.
Making the Next One Small
This is at least the third round of this class of bug since 2018, so it pays to make the next fix cheap. Build new or untrusted code in a job that holds no deploy secrets, so a poisoned dependency finds nothing worth stealing. Our guides on ephemeral CI runners and on keeping CI secrets out of reach cover both halves of that. Then keep the Go version in one place per repository, so the next point release is a one-line change, not a search across every Dockerfile and workflow.
What This Means for Your Team
Plan it for this week and skip the fire drill. Move your CI images and workflows to Go 1.27.4 or 1.26.11, rebuild, and redeploy. The 9.8 describes the worst case for a build that compiles a deliberately poisoned package, and the fix for that case is already a week old. If you want a second opinion on how urgent a score like this really is for you, our guide to reading a CVE and deciding in ten minutes walks through it.
If you would like us to find every place Go gets built across your repositories and runners and move them in one pass, that is part of our DevOps and security and compliance work.
Sources
- Go 1.27.4 and Go 1.26.11 security release announcement
- Go release history
- GO-2026-6851, CVE-2026-97040
- Go issue 82570
- NVD, CVE-2026-97040
- GO-2026-6859, CVE-2026-97054 in net/http
- GO-2022-0201, CVE-2018-6574
- Go security policy
- Ubuntu, CVE-2026-97040
- Debian security tracker, CVE-2026-97040
- Go toolchains documentation
Read how we handle it in Cybersecurity.
Related News
cPanel and Plesk Both Patched a Root Escalation the Same Day
On August 27 both control panels shipped a fix for a customer account becoming root. They read as the same bug and they are not. One needs nothing but a normal hosting account, the other needs shell access and can be blocked without patching.
SecurityIf You Use Gravity SMTP On WordPress Rotate Your Email API Keys Now
CVE-2026-4020 in the Gravity SMTP WordPress plugin (about 100,000 installs) lets an unauthenticated attacker pull your email provider API keys straight off the site, and bots are mass-exploiting it. It is rated CVSS 7.5 (High). Here is what leaks, why it deserves immediate attention, and the patch-and-rotate steps.
Securitynginx 1.30.7 and 1.31.9 Fix Two HTTP/2 Code Execution Bugs
nginx 1.30.7 and 1.31.9 shipped on November 18 with fixes for CVE-2026-123007 and CVE-2026-123633, two HTTP/2 bugs that can let an attacker run code on the server. How to check your servers, patch them, and switch HTTP/2 off until you can.