Daily Engineering Intelligence

Technology Newspaper

← Back to Home

Engineering Intelligence — Thursday

November 5, 2026

🔥 What Changed

A quiet Thursday with three items. A new Go net/http report shows that the common "let GET handlers answer HEAD" middleware trick, which rewrites r.Method, makes the HTTP/1 server write a body after a HEAD response on a kept-alive connection, so the client misreads the next response; a fix is in review. OpenAI published the numbers from an autonomous Linux kernel bug-hunting pipeline: 948 working local-root exploits from one run, which changes how much an unpatched node with a low-privileged foothold is worth. For Worth Your Time, Figma's write-up on Nimbus is a compact, concrete tour of running tens of thousands of sandboxes across several providers.

Also seen: Caddy v2.11.9 (11-05 07:00 IST) fixes a 2.11.8 PHP directory-index regression and several FastCGI security issues (client headers could override env-set HTTP_* variables, GHSA-q34h-28rj-5hjm; Windows 8.3/ADS script bypass, GHSA-9cr8-wmhh-39pm), and now errors on conflicting client_auth instead of silently dropping the stricter mTLS policy. Go #82858: crypto/x509 turns each 2-byte empty URI SAN into a heap url.URL, so a 260 KB client certificate costs about 27 MB per mTLS handshake even if it's rejected (Go security team says not a security issue). Go #82851: the experimental HTTP/3 server accepts conflicting or invalid Content-Length. Strimzi 1.3.1 adds Kafka 4.3.2 and fixes post-Vert.x concurrency issues (Kubernetes 1.32+ only). RKE2 v1.37.2/v1.36.6/v1.35.10/v1.34.13 patch releases. Confluent's Q4'26 "Streamhouse" launch posts are marketing-heavy and were skipped.

Holds: Go 1.27.4/1.26.11 (go.dev/dl still 1.27.3/1.26.10; carrying CL 858262 for #82825 and CL 857344 for #82777); gopls release with CL 858103 (proxy still v0.24.0); CL 858982 backport decision; Go #82717 MPTCP default; CVE-2026-98432 Ubuntu -updates and OpenShift; x/oauth2 CL 854305; Kafka 3.9.3; moby/swarmkit GHSA publication; Postgres 19 RC2 11-12 / GA 11-19. Alternates: x/net/idna #82864 infinite loop (unrealistic config), Amazon ECS Gateway (InfoQ), Docker on AI-agent isolation (InfoQ), Dragonfly v2.1, Valkey 9.2.0-rc2, MinerU 4.1.7, Docling 2.147.0, Dharma Field Extractor (HF), Loki 4.0.0-rc.2.

Go net/http: middleware that rewrites a HEAD request to GET makes the HTTP/1 server send the body after a HEAD response and keep the connection open, so the client reads it as the start of the next response (go1.27.3 and master)

A common way to let GET handlers serve HEAD is a wrapper that does if r.Method == http.MethodHead { r.Method = http.MethodGet }. The reporter's program sends HEAD /a then GET /b on one connection and gets back a HEAD-framed header (Content-Length: 10) followed by body of /a, then the /b response, all on a connection the server keeps open. A client stops reading a HEAD response at its header, so those stray bytes become the start of what it parses as the next response. The cause: CL 847311 (the CONNECT desync fix for #81744, Go 1.28 only) made chunkWriter.writeHeader frame by the method as read off the wire, but chunkWriter.Write, response.ReadFrom and shouldReuseConnection still look at the handler-mutated w.req.Method. The same applies to the protocol version: a handler that bumps an HTTP/1.0 request to 1.1 gets a chunked 1.1 response sent to a 1.0 client on a kept-open connection. CL 858982 ("frame HTTP/1 server responses by the request as read", #82861) records the method and HTTP/1.1-ness when the response is created and frames everything by those. It isn't labelled as a security issue and has no milestone yet.

Why you care: This is a response-desync bug in the standard server, triggered by an ordinary middleware pattern rather than a hostile client, and behind a pooling proxy or load balancer the misread response can land on a different request. It's cheap to check: grep your routers and middleware for code that assigns r.Method (or r.Proto*), and have HEAD handling call the GET handler with a cloned request or a body-discarding ResponseWriter instead of mutating the request. Watch #82853 for a backport decision.
Read Go issue #82853 → Also: go.dev →

OpenAI's autonomous kernel pipeline produced 948 distinct working Linux local-root exploits in one mid-October run on a stock desktop distro, at about $1,279 each, and OpenAI now says a low-privileged account on an unpatched host should be treated as root

The pipeline uses scout agents to pick security-relevant, unprivileged-reachable code (5,034 targets, about 7% of the kernel), analyst agents to produce 2,308 candidate findings in 12 hours, triage agents that reproduced 1,724 under KASAN in 30 hours (74.7%; only 3.1% were wrong analysis), and exploit agents that got working root exploits past SMEP, SMAP, KASLR and HARDENED_USERCOPY; variant analysis collapsed those to 948 unique bugs with patches. The full run cost $1,213,430 in API credits. On a kernelCTF-style hardened kernel it got 21 local-root exploits for about $33K, against 26 accepted kernelCTF 0-days so far in 2026. A July run with an earlier model found 166. Hundreds of reports and patches have gone to maintainers, and within the 10-day run 61 of the bugs were already fixed upstream and 43 had staging patches. They also found and exploited a QEMU TCG bug in their own test setup and say they've disclosed issues in Kata, Moby/Docker and gVisor.

Why you care: For anyone running multi-tenant Kubernetes nodes, CI runners or shared build hosts, the boundary that matters is now the sandbox layer, not "the attacker only has a container shell". Expect an unusually heavy kernel CVE flow from distros over the coming weeks; keep node images on a short patch cadence, and for untrusted workloads (CI, user code, AI-agent sandboxes) prefer gVisor, Kata or Firecracker over plain runc, which is the same advice the report gives.
Read OpenAI report →

📚 Worth Your Time

How Figma manages sandboxes at scale: Nimbus, a declarative control plane over several sandbox providers with warm pools, exactly-once claims in Postgres and health-weighted provider routing

Product teams declare a "namespace" (image, CPU/memory, health check, warm-pool min/max, allowed hosts), in the style of a Kubernetes operator, and call GetOrCreate/Get/Delete. Egress policy separates reads from writes: allowlisted hosts get full access, everything else only GET/HEAD/OPTIONS without a body, enforced by the provider or a proxy sidecar, and it fails closed. Credentials enter the sandbox encrypted and are swapped for the real value only on the way out to the intended destination. Warm pools cut provisioning latency by 90% and lifted provisioning availability from 99% to 99.95%. Claims are a single Postgres transaction that skips rows another request is claiming, the pool is resized from the observed claim rate, and provider weights shift with recent outcomes, with client cancellations and self-imposed rate limits excluded from the circuit breaker. A simulator caught a real feedback bug: slow-but-successful providers kept looking healthy while the pool drained, so slow successes now cut a provider's weight and provisioning moved out of the control loop.

Why you care: It's a short, concrete case study in control loops, idempotent GetOrCreate keys, SKIP LOCKED-style work claiming and multi-provider failover, all of which come up in distributed-systems design interviews and in real platform work.
Read Figma article →