Daily Engineering Intelligence

Technology Newspaper

← Back to Home

Engineering Intelligence — Saturday

November 14, 2026

🔥 What Changed

A quiet Saturday with three items. ZITADEL 4.20.3 fixes eight advisories at once, including two full authentication bypasses: a Login V1 OIDC authorization code that was not bound to the user who signed in, and Login V2 completing OIDC/SAML requests with a zero-factor session. Every 4.x release up to 4.20.2 is affected. A fresh Go net/http report (#83068) shows that cancelling the request context does not unblock an HTTP/2 Response.Body.Read while the request body is still streaming; HTTP/1 returns context canceled. For Worth Your Time, Fly.io explains how it replaced a fleet-wide, eventually consistent in-kernel routing map with lazy on-demand lookups.

Also seen: Go #83065 goroutineleak profile freezes synctest bubbles (_Gleaked counted as running); Go #83058 crypto/tls processClientHello only uses the first sorted group; Go #83056 HTTP/2 server fails over TLS 1.2 when 128-bit ciphers are disabled. Go #83036 (phiopt miscompile) cc'd to the compiler team, no CL yet. Helm v4.3.2 (registry transport fix). Traefik v3.7.19/v2.11.63 (dependency bumps, x/crypto v0.59.0). Mimir 3.2.5/3.1.10, Loki 3.7.10. Linkerd edge-26.11.2. Cloudflare open-sourced Kitesurf, its Workers-based agent browser (Apache 2.0). llama.cpp v1.0.0. Surya v0.24.0, MinerU 4.2.2. Netflix operational knowledge graph for AI observability (InfoQ).

Holds: Go 1.27.5/1.26.12 (CVE-2026-97047 #82948, CVE-2026-97044 #82374 backports); Go #83036 fix CL; Go #83068/#83069 triage; Go #82945 TLSNextProto h2 regression; Keycloak CVE-2026-120984 fix (still 26.8.2); gopls release for #82821 + #82891; CVE-2026-98432 OpenShift CoreOS; x/oauth2 CL 854305; Kafka 3.9.3 (code freeze 11-20); Postgres 19 GA ~11-19.

ZITADEL 4.20.3: eight advisories, including OIDC authorization-code and zero-factor-session authentication bypasses across all 4.x

Eight GitHub advisories were published with the release. GHSA-3985-45jm-558m (CVSS 8.1): Login V1 authorization codes were not reliably bound to the user who completed sign-in. An attacker with their own account who knows a victim's login name can get ID, access and refresh tokens for the victim, skipping every factor (password, passkey, TOTP, U2F, external IdP). GHSA-3gwf-ph53-v73c (7.4): OIDC/SAML requests could be completed with a session on which no factor was verified. This is reachable through Login V2 and directly through the completion endpoints, because the session.link permission was not enforced. GHSA-qvxq-53gh-64f6 (8.1): a bypass of October's host-header fix. Putting the trusted host in the userinfo part of x-zitadel-public-host redirects real password-reset and invite links, codes included, to an attacker's host. Also fixed: Login V2 server functions callable without authentication under the instance-wide service account (GHSA-vg5j), the org "disable local auth" policy not enforced on password checks (GHSA-gx82), login CSRF on external IdP callbacks, an open redirect, and OTP factors added without confirmation. Affected: >= 4.0.0, <= 4.20.2 (the host-header bypass affects 4.19.5+). There are breaking upgrade notes: a custom login UI's service user needs IAM_LOGIN_CLIENT before you upgrade, and unredeemed V1 codes are rejected once.

Why you care: Auth/IAM is a rising board category, and ZITADEL is a Go/gRPC identity provider. These are textbook OIDC flow-binding bugs (code ↔ authenticated subject, request ↔ verified session). They're the checks to look for in any authorization server you build or review. This is the second ZITADEL takeover batch in a month (10-18).
Read ZITADEL v4.20.3 release → Also: github.com →

Go #83068: cancelling the request context does not unblock an HTTP/2 Response.Body.Read while the request body is unfinished

The client sends an HTTP/2 POST with an io.Pipe body that never finishes. The server flushes response headers and waits for the body. The client's Do returns, the client cancels the context, then reads the response. Read is still blocked five seconds later. With HTTP/2 disabled it returns context canceled straight away. In the transport, the request writer is blocked in the request body's Read while the response reader waits on cs.bufPipe.Read, and neither path checks cancellation. Reproduced on go1.26.11, go1.27.3, go1.27.4 and tip. The workaround from the report is to close the pipe yourself on cancellation: context.AfterFunc(ctx, func() { pw.CloseWithError(ctx.Err()) }). The issue is untriaged with no CL yet. A sibling report, #83069, shows a server hang after a handler panic (for example ReverseProxy's ErrAbortHandler) when the client sent Expect: 100-continue and never sends its body.

Why you care: Go is your top weight, and this goes straight at the context.Context cancellation-ownership theme you're studying. The documented contract ("the request context also controls reading the response body") silently breaks over HTTP/2 for streaming uploads, such as gRPC-style bidi over plain net/http or proxied uploads. If you stream request bodies, tie the body writer to the context with context.AfterFunc rather than trusting the transport.
Read Go issue #83068 → Also: github.com →

📚 Worth Your Time

Fly.io: Throwing Out The Phonebook — rebuilding the 6PN private network by dropping a fleet-wide replicated routing map for lazy lookups

Every Fly Machine's IPv6 address encodes the host it was born on. Once Machines could migrate, every host had to hold a "phonebook" in an eBPF map listing where every migrated Machine now lives. That map had hundreds of thousands of entries, was fed by a fleet-wide subscription to Corrosion (their gossip-replicated SQLite), and was approaching its cap. Hosts held "vastly different numbers of entries", so sync was clearly failing, and nobody could see where. The new design uses VXLAN's "unknown address" netlink event. A daemon looks up the destination in local Corrosion, installs one route and moves on, so most hosts now hold 100–200 routes. Failures retry naturally on TCP retransmit. A stale route costs one extra forwarding hop instead of a broken connection, and the eBPF program shrinks to a fail-closed same-network check. The costs are stated plainly: the first connection between two Machines that have never talked takes about 1 s (the Linux RTO), and a daemon crash breaks only new conversations. The migration ran both paths at once, opted in host by host with asymmetric routing.

Why you care: This is a clean distributed-systems lesson: don't keep a real-time replica of an eventually consistent database on every node if each node only needs a tiny working set. Pull lazily, cache, re-validate and make staleness cheap. It applies directly to service discovery, sidecar config fan-out and Kubernetes endpoint propagation.
Read Fly.io 6PN post →