Vraag een .NET-team hoeveel nginx-instanties er in productie draaien en je krijgt meestal "één, de reverse proxy". Tel ze daarna echt. De SPA-container met de Angular-frontend draait op nginx:alpine. Het Kubernetes-cluster heeft een ingress controller die toevallig ook nginx is. En op de oude VM die niemand meer durft aan te raken staat nog een sites-enabled uit 2021.
Dat tellen is deze week ineens dringend. Wiz Research publiceerde op 18 november twee kritieke HTTP/2-lekken in nginx, allebei uit te buiten zonder authenticatie, allebei met een CVSS 4.0-score van 9.2. Op Hacker News kwam het verhaal op 1100 punten en bijna 500 reacties. Dat is veel voor een CVE. De reden is simpel: half het internet zit achter nginx.
Wat er precies lek is
Volgens Wiz gaat het om twee fouten in de HTTP/2-code van nginx:
- CVE-2026-123633 is een use-after-free bij hergebruik van HTTP/2-verbindingen. Het speelt bij reverse-proxyverkeer, op het moment dat de vrije connection slots opraken. Getroffen versies: 1.19.7 tot en met 1.31.8.
- CVE-2026-123007 is een integer underflow in
send_window, de teller waarmee nginx de flow control van een hele verbinding bijhoudt. Wiz demonstreerde deze over HTTPS op 64-bit systemen, met nginx die zelf content serveert. Getroffen versies: 1.9.5 tot en met 1.31.8. Die bug zit er dus al ruim tien jaar in.
De fixes zitten in nginx 1.30.7 (stable) en 1.31.9 (mainline). Wiz heeft werkende proof-of-concepts gebouwd maar publiceert ze voorlopig niet. Het eerste rapport ging op 21 oktober naar F5, de patch kwam op 10 november en de publieke disclosure op 17 en 18 november.
Equixly telt in totaal vijf lekken in deze release. Naast de twee HTTP/2-bugs gaat het om een fout in de DNS-resolver (CVE-2026-123634), een in HTTP/3 met QUIC (CVE-2026-121810) en een in de mail proxy (CVE-2026-113425). Dat detail is belangrijk zodra je over de workaround gaat nadenken.
In de Hacker News-discussie viel nog iets op: volgens de thread vonden vijf onafhankelijke teams deze bugs rond dezelfde tijd. Of dat door nieuwe AI-modellen voor vulnerability research komt, weet niemand, maar het effect is hetzelfde: de tijd tussen disclosure en een werkende exploit in het wild wordt korter. Volgens reacties in de thread waren de Ubuntu- en Debian-pakketten op dat moment nog niet bijgewerkt en liepen ook de Docker-images achter.
Waarom dit een .NET-probleem is
Kestrel is een prima webserver. Toch zetten de meeste teams die ik tegenkom er nginx voor, om TLS te termineren, statische files te serveren of meerdere services achter één hostname te hangen. Die nginx valt vaak tussen twee stoelen. Het is geen applicatiecode, dus de developers voelen zich er niet verantwoordelijk voor. En omdat hij in een container zit, valt hij ook niet onder de OS-patchronde van de beheerders.
Dit zijn de plekken waar ik hem bij klanten tegenkom:
- De edge-proxy in een Docker Compose-stack, die TLS termineert en doorstuurt naar
api:8080. - Een frontend-container (
FROM nginx:alpine) die een gebuilde React- of Angular-app serveert, vaak met eenproxy_passnaar de API erachter. - ingress-nginx in Kubernetes.
- Een sidecar of "kleine" cache die iemand ooit heeft toegevoegd.
Punt 3 vraagt extra aandacht. Kubernetes heeft ingress-nginx met pensioen gestuurd: sinds maart 2026 komen er geen releases, bugfixes of security-updates meer. Draai je hem nog, dan moet je er niet op rekenen dat iemand een gepatchte build voor je klaarzet. Wat deze CVE's voor die specifieke build betekenen moet je zelf uitzoeken. Het verstandigste antwoord is de migratie naar Gateway API of een andere controller nu wel in te plannen.
Stap 1: tel ze echt
Op een Docker-host vind je met dit script elke container die een nginx-binary heeft, ook als het image er niet naar heet:
#!/usr/bin/env bash
# nginx-inventory.sh: toont de nginx-versie in elke draaiende container
docker ps --format '{{.ID}} {{.Names}} {{.Image}}' | while read -r id name image; do
# nginx -v schrijft naar stderr; containers zonder nginx falen stil
if version=$(docker exec "$id" sh -c 'for b in nginx openresty; do command -v "$b" >/dev/null 2>&1 && exec "$b" -v 2>&1; done; exit 1' </dev/null 2>/dev/null); then
echo "$name ($image): $version"
fi
done
Distroless-containers hebben geen sh en vallen hier buiten. In de praktijk draait nginx bijna nooit distroless, dus dat accepteer ik.
In Kubernetes zoek je eerst op image-naam en controleer je daarna per pod:
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{range .spec.containers[*]}{.image}{" "}{end}{"\n"}{end}' \
| grep -Ei 'nginx|openresty'
Image-namen zijn hier alleen een eerste filter. Een image dat company/frontend:4.2 heet kan net zo goed nginx bevatten, dus kijk ook in de Dockerfiles in je repo's:
grep -rEn --include='Dockerfile*' '^FROM .*(nginx|openresty)' .
Stap 2: weet waar HTTP/2 termineert
Beide HTTP/2-lekken vereisen dat HTTP/2 aan staat op een listener die bereikbaar is voor de aanvaller. In een typische setup praat de browser HTTP/2 met nginx en praat nginx HTTP/1.1 met Kestrel. Het risico ligt dan helemaal bij nginx.
De config vertelt wat iemand ooit bedoeld heeft. Ik wil weten wat een endpoint vandaag aanbiedt. Een kleine .NET-tool vraagt via ALPN welk protocol de server kiest en leest de Server-header uit:
// dotnet new console -n AlpnProbe ; vervang Program.cs ; dotnet run -- example.com api.example.com
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
foreach (var host in args)
{
try
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
using var tcp = new TcpClient();
await tcp.ConnectAsync(host, 443, cts.Token);
await using var tls = new SslStream(tcp.GetStream());
await tls.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
{
TargetHost = host,
ApplicationProtocols = [SslApplicationProtocol.Http2, SslApplicationProtocol.Http11]
}, cts.Token);
var alpn = tls.NegotiatedApplicationProtocol.Protocol.Length == 0
? "(geen ALPN)"
: tls.NegotiatedApplicationProtocol.ToString();
using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(5) };
using var request = new HttpRequestMessage(HttpMethod.Head, $"https://{host}/")
{
Version = HttpVersion.Version20,
VersionPolicy = HttpVersionPolicy.RequestVersionOrLower
};
using var response = await http.SendAsync(request);
var server = response.Headers.Server.ToString();
Console.WriteLine($"{host,-30} alpn={alpn,-10} server={(server.Length > 0 ? server : "(verborgen)")}");
}
catch (Exception ex)
{
Console.WriteLine($"{host,-30} fout: {ex.GetType().Name}: {ex.Message}");
}
}
Krijg je alpn=h2 en server=nginx/1.27.3, dan weet je genoeg. Staat server_tokens off aan, dan zie je alleen nginx en moet je de versie op de host zelf opvragen. Die tool draai ik graag in een pipeline tegen de lijst publieke hostnames. Zo merk je het ook als iemand later een nieuw subdomein met een eigen proxy aanmaakt.
Stap 3: patchen, of tijdelijk http2 off
Patchen is de echte oplossing. Voor containers betekent dat een nieuwe build, want een image dat je in september hebt gebouwd blijft de nginx uit september draaien, wat de upstream-tag ook doet. Pin daarom op een versie waarvan je weet dat hij gefixt is, en controleer het in CI. Een tag alleen bewijst niets.
# controleer eerst of deze tag op Docker Hub bestaat
FROM nginx:1.30.7-alpine
COPY nginx.conf /etc/nginx/nginx.conf
COPY dist/ /usr/share/nginx/html/
# CI-stap: faal als de gebouwde image een kwetsbare nginx bevat
v=$(docker run --rm myapp/frontend:"$GIT_SHA" nginx -v 2>&1 | sed -E 's|.*nginx/([0-9.]+).*|\1|')
required="1.30.7"
case "$v" in
1.31.*) required="1.31.9" ;;
esac
if [ "$(printf '%s\n%s\n' "$required" "$v" | sort -V | head -n1)" != "$required" ]; then
echo "nginx $v is kwetsbaar (minimaal $required vereist)"; exit 1
fi
echo "nginx $v ok"
Kun je nog niet patchen, omdat de distro of de vendor van je appliance achterloopt, dan adviseert Wiz HTTP/2 tijdelijk uit te zetten. Vanaf nginx 1.25.1 gaat dat met de http2-directive per server-blok. In oudere versies haal je http2 uit de listen-regel.
server {
listen 443 ssl; # geen 'http2' meer op de listen-regel
http2 off; # nginx 1.25.1 en nieuwer
server_name api.example.com;
ssl_certificate /etc/nginx/certs/fullchain.pem;
ssl_certificate_key /etc/nginx/certs/privkey.pem;
location / {
proxy_pass http://api:8080;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}
Die workaround heeft twee addertjes, en vooral het eerste vergeten mensen.
Het eerste is gRPC. Een gRPC-client spreekt HTTP/2, en nginx kan grpc_pass alleen gebruiken op een listener die HTTP/2 aanbiedt. Gebruik je ASP.NET Core gRPC achter nginx, dan breekt http2 off die services direct. Je kunt gRPC-verkeer dan tijdelijk via een aparte hostname rechtstreeks naar Kestrel sturen, of overstappen op gRPC-Web, dat ook over HTTP/1.1 werkt. Gaat geen van beide snel, dan wordt patchen je enige echte optie, en dat moet dan vandaag.
Het tweede: http2 off dekt maar twee van de vijf lekken. Heb je listen 443 quic voor HTTP/3 met proxying naar upstreams, dan hoort de QUIC-bug ook bij jou. En dan het resolver-lek. Equixly noemt als voorwaarde de combinatie van resolver, een proxy_pass met een variabele en subrequests. Die combinatie is in Docker-land opvallend gewoon. Veel teams gebruiken dit trucje zodat nginx niet crasht als de API-container nog niet draait:
resolver 127.0.0.11 valid=10s; # Docker embedded DNS
set $upstream http://api:8080;
proxy_pass $upstream;
Voeg je daar auth_request aan toe, dat met subrequests werkt, dan zit je in de buurt van de beschreven voorwaarden. Controleer je eigen config aan de hand van de advisory van F5. Bij twijfel geldt: patchen.
Is Kestrel aan de rand dan beter?
Reacties als deze komen in elke HN-thread voorbij: "gooi nginx eruit en zet Caddy of HAProxy ervoor", of in .NET-termen "zet Kestrel direct op het internet". Ik snap de reflex. Een C-codebase met tien jaar oude HTTP/2-code zonder bounds checking maakt de discussie over memory safety niet bepaald zwakker.
Toch is het geen gratis upgrade. Kestrel is managed code, dus een use-after-free is daar veel minder waarschijnlijk. Maar logische fouten in HTTP/2 kunnen er net zo goed in zitten. De Rapid Reset-aanval van oktober 2023 (CVE-2023-44487) raakte nginx en ASP.NET Core allebei. HTTP/2 is een ingewikkeld protocol, en die complexiteit verhuist mee naar elke server die het termineert.
Kies je toch voor Kestrel aan de rand, of voor YARP als proxy in .NET, zet de HTTP/2-limieten dan bewust neer en laat ze niet op de defaults staan:
using Microsoft.AspNetCore.Server.Kestrel.Core;
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel(options =>
{
options.AddServerHeader = false;
var limits = options.Limits;
limits.MaxConcurrentConnections = 2_000;
limits.MaxConcurrentUpgradedConnections = 200;
limits.KeepAliveTimeout = TimeSpan.FromSeconds(60);
limits.RequestHeadersTimeout = TimeSpan.FromSeconds(15);
limits.Http2.MaxStreamsPerConnection = 50; // default is 100
limits.Http2.MaxRequestHeaderFieldSize = 8 * 1024;
limits.Http2.KeepAlivePingDelay = TimeSpan.FromSeconds(30);
limits.Http2.KeepAlivePingTimeout = TimeSpan.FromSeconds(10);
options.ListenAnyIP(8443, listen =>
{
listen.Protocols = HttpProtocols.Http1AndHttp2;
listen.UseHttps("/certs/api.pfx", Environment.GetEnvironmentVariable("CERT_PASSWORD"));
});
});
var app = builder.Build();
app.MapGet("/health", () => Results.Ok());
app.Run();
Het eigenlijke punt is dat je per laag weet wie hem patcht. Voor de .NET-runtime is dat je base image plus een rebuild. Voor nginx in een container is het precies hetzelfde, en precies daar gaat het mis. Bij een managed load balancer of Cloudflare ligt het patchen bij de leverancier. Dat is dan ook het argument voor een managed edge: je kunt dit soort weken aan iemand anders overlaten.
Wat ik vandaag zou doen
Eerst het inventarisscript op elke Docker-host en de kubectl-query op elk cluster. Daarna de ALPN-probe tegen alle publieke hostnames, zodat je weet waar HTTP/2 echt aan staat. Waar een gefixte nginx beschikbaar is: rebuilden, deployen en de CI-check toevoegen, zodat je volgende frontend-image niet ongemerkt terugvalt naar een oude versie. Waar dat nog niet kan: http2 off, na eerst te controleren of er gRPC over die listener loopt.
En wie ingress-nginx nog draait, zet de migratie op de planning van deze sprint. Dat project krijgt geen fixes meer, en nginx2root zal niet de laatste reden zijn om dat te betreuren.
Veelgestelde vragen over de nginx HTTP/2-lekken
Ben ik kwetsbaar als nginx alleen intern tussen containers draait? Het risico is kleiner, want een aanvaller moet de listener met HTTP/2 kunnen bereiken. Maar interne proxies zijn bereikbaar voor alles in hetzelfde netwerk, ook voor een gecompromitteerde container, dus ze mogen later aan de beurt komen, als ze maar aan de beurt komen.
Werkt de app nog als ik http2 off zet? Voor gewone REST-API's en websites wel, browsers vallen dan terug op HTTP/1.1 en merken weinig. Services die echte gRPC over nginx gebruiken breken wel, omdat grpc_pass een HTTP/2-listener nodig heeft, dus controleer dat voordat je de config uitrolt.
Is server_tokens off genoeg om niet gevonden te worden? Nee, het verbergt alleen het versienummer in de Server-header. Scanners herkennen nginx ook aan foutpagina's, headervolgorde en TLS-gedrag, en een aanvaller probeert de exploit gewoon tegen elk adres dat HTTP/2 aanbiedt.
Krijgt mijn nginx-container de fix vanzelf als het officiële image is bijgewerkt? Nee. Je draaiende container blijft de nginx bevatten van het moment waarop je hem bouwde of pullde, dus pas na een nieuwe build of pull en een herstart draait de gepatchte versie, ook als je een tag als nginx:stable-alpine gebruikt.
Moet ik overstappen van nginx naar Kestrel of YARP aan de rand? Alleen als je dat om andere redenen ook al wilde. Kestrel heeft minder kans op geheugenfouten, maar HTTP/2-logicafouten zoals Rapid Reset raakten ook ASP.NET Core, en zonder eigen limieten en een patchproces voor de runtime verplaats je het risico alleen.
Verder lezen
- GitLab gepatcht, Ruby niet: wat het Alpine-incident .NET-teams leert over runtime-updates
- Netwerken in Docker Compose: services laten samenwerken in productie
- IP-blokkeren is dood: wat de DDoS op Read the Docs .NET-teams leert
Conclusie: De nginx voor je .NET-app is net zo goed jouw code als je controllers. Tel elke instantie, ook die in de frontend-container en de ingress controller, controleer waar HTTP/2 termineert, en laat CI falen op een kwetsbare versie. http2 off geeft je tijd, maar dekt drie van de vijf lekken niet en breekt gRPC.
Bronnen: Wiz Research: NGINX HTTP/2 RCE vulnerabilities · Equixly: disabling HTTP/2 stops two of five nginx RCE flaws · Kubernetes: Ingress NGINX Retirement · Hacker News-discussie.
