Skip to main content

Go 1.27.4 Closes Eleven Ways a Build Could Run Code

9 min read
Update Go in my pipelines

We move every Dockerfile and workflow to Go 1.27.4, then rebuild and redeploy your services.

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.

DateWhat happened
October 26, 2026Go issue 82570 created for the .syso bug
November 10, 2026Go 1.27.4 and 1.26.11 released with all twelve fixes
November 11, 2026The CVE records published, with no severity score
November 16, 2026CISA added its 9.8 and 8.8 scores to the NVD records
November 18, 2026No 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

CVEWhat was wrongWhere it applies
CVE-2026-97040A .syso file disguised as a Go object smuggled linker flags past validationAny platform
CVE-2026-97038.syso files and library inputs could carry linker scripts or embedded linker optionsAny platform
CVE-2026-97043Escaped quotes in cgo_ldflag directives let disallowed flags throughAny platform
CVE-2026-97041Commas in go:cgo_* directives injected flags into the external linkerELF platforms such as Linux
CVE-2026-97042Library names were checked by their first character only, and DLL names in PE objects not at allWindows for the DLL part
CVE-2026-97037Split -Wl, flags handed linker scripts to the host linkerHost linker, GNU ld in particular
CVE-2026-97039#cgo pkg-config directives could load untrusted .pc filesBuilds that use pkg-config
CVE-2026-97033--sysroot, -target, -isysroot and -x pointed the compiler at attacker filesGCC and Clang
CVE-2026-97034GCC could load spec files from attacker-controlled directoriesGCC
CVE-2026-97035Clang -gen-* and GCC -gnat* flags wrote files or confused flag parsingGCC and Clang
CVE-2026-97036-l to_library loaded an arbitrary plugin into the Apple linkermacOS
CVE-2026-97054A MaxBytesReader header race could crash an HTTP/1 serverPrograms 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

Read how we handle it in Cybersecurity.