Security · Web servers

nginx and Apache both patched HTTP/2 memory-corruption flaws. Is your container exposed?

Apache httpd 2.4.71 and nginx 1.30.7 fix unauthenticated memory corruption in their HTTP/2 code. Whether a container on App Runner, ECS, Cloud Run or Azure Container Apps is reachable depends on one thing: which protocol the platform's proxy speaks to it. How to check, and what to patch.

Pikabyte Engineering 14 min read

HTTP/1.1

is what App Runner, a default ALB target group and Cloud Run send to your container. The HTTP/2 flaws need HTTP/2 to reach it

In the space of a week in November 2026, the two most widely used open-source web servers shipped fixes for the same class of problem: memory corruption in the HTTP/2 code, reachable without authentication.

Apache released httpd 2.4.71 on 11 November for CVE-2026-119618. nginx released 1.30.7 and 1.31.9 on 18 November for ten CVEs, led by CVE-2026-123007.

Most small teams do not run these servers on a virtual machine any more. They run them inside a container on App Runner, ECS, Cloud Run or Azure Container Apps, behind a proxy the cloud provider operates. So the practical question is whether that proxy protects you.

The short answer: for the two headline bugs, often yes, and for a specific reason you can check in one command. For the rest of the release, no. And either way the image has to be rebuilt.

What was disclosed

Apache httpd: CVE-2026-119618

Apache describes it as “Concurrent Execution using Shared Resource with Improper Synchronization vulnerability in Apache HTTP Server’s mod_http2 in assign_headers() can lead to RCE.”

  • Affected: httpd 2.4.55 to 2.4.70. Fixed in 2.4.71.
  • Severity: Apache rates it critical. Red Hat scores it 9.8 under CVSS 3.1.
  • Cause, per Red Hat: “a worker thread writes into memory owned by the connection thread through a shared, lock-free allocator.”
  • Precondition: HTTP/2 must be enabled, meaning h2 or h2c appears in a Protocols directive. Loading the module is not enough. Apache’s default is Protocols http/1.1.
  • Credit: Anthropic’s OSS Scanner, and Anthony Weems and Simon Scannell of Google Cloud Vulnerability Research.

Red Hat rates its own RHEL 9 and 10 packages Important, not Critical, because they allocate each HTTP/2 stream from a separate allocator. RHEL 8 and earlier do not contain the affected code.

On exploitation, sources moved over a week. Wiz wrote on 11 November that no exploit was available and none was reported in the wild. On 17 November Singapore’s Cyber Security Agency published an alert saying: “This vulnerability is reportedly being actively exploited, and a proof-of-concept exploit is publicly available.” The alert gives no detail on victims.

nginx: ten CVEs, two of them in HTTP/2

CVE What it is nginx.org severity Affected Needs
CVE-2026-123007 Memory corruption in HTTP/2 flow control major 1.9.5 to 1.31.8 HTTP/2 enabled on a listener
CVE-2026-123633 Use-after-free in HTTP/2 medium 1.19.7 to 1.31.8 HTTP/2, a proxied request, and connection slots running low
CVE-2026-123634 Use-after-free in the resolver medium 0.6.18 to 1.31.8 The resolver directive, with one name resolved at the same time in subrequests
CVE-2026-121810 Use-after-free in HTTP/3 medium 1.25.0 to 1.31.8 HTTP/3 (QUIC) enabled
CVE-2026-113425 Use-after-free in the mail proxy major 0.5.33 to 1.31.8 The mail proxy module in use
CVE-2026-118899 Endless loop reading a request body over TLS 1.3 major 1.13.0 to 1.31.8 nginx terminating TLS itself

The other four are smaller: a buffer overflow with alias and try_files in certain configurations, a crash with PROXY protocol v2 (1.31.4 to 1.31.8 only), and two issues in the stream module.

All are fixed in 1.30.7 (stable) and 1.31.9 (mainline).

Severity depends on who you ask. nginx.org’s changelog says only that the flow-control flaw “might allow an attacker to cause a segmentation fault in a worker process, or might have potential other impact”. F5’s advisory, as reproduced by Debian, says code execution is possible where ASLR is disabled or can be bypassed, and scores the two HTTP/2 bugs 9.2 under CVSS 4.0 and 8.1 under CVSS 3.1. Rapid7, Wiz and Xint each report achieving code execution with ASLR on, because the same bug can first be used to read memory.

How CVE-2026-123007 works

HTTP/2 uses flow control. Each side tells the other how many bytes it may send, per stream and per connection, and tops the allowance up with WINDOW_UPDATE frames. The protocol caps a window at 2^31 - 1.

According to Rapid7’s analysis, nginx enforces that cap when a WINDOW_UPDATE arrives, but not on a second path: when a stream is closed with response data still queued, the unsent bytes are credited back to the connection window with no upper-bound check. An attacker who repeats this pushes the counter past the maximum. Later arithmetic on it wraps around, and a nonsensical length reaches a memcpy in the TLS send path. The result is a constrained read and write on the worker’s heap.

Three properties matter for defenders.

  • It needs no special configuration. Wiz demonstrated it against nginx “serving ordinary static files, without a backend application or third-party modules.”
  • Your logs will not show it. Xint notes that the control frames involved “are not logged as requests, and TLS encrypts them in transit.”
  • A WAF cannot stop it. AWS’s bulletin: “Because these issues can be leveraged at the HTTP/2 protocol layer before a complete HTTP request is formed, AWS WAF managed and custom rules cannot effectively detect or block them.”

It is not trivial to exploit. Rapid7’s public proof of concept sends about 128 GB of HTTP/2 data and depends on a particular memcpy implementation. Cloudflare describes it as suitable only for a freshly started local container. As of 19 November, Cloudflare had seen no reports of exploitation in the wild. Treat that as a short head start, not a verdict.

Why it is called nginx2root

Code running as the nginx worker is not root. Xint chained the nginx bug with a separate use-after-free in the Linux kernel’s SCTP code and reported reaching root on the host, including from nginx inside a Docker container. As of 18 November there was no kernel fix, and the details are withheld.

The one question: what speaks HTTP/2 to your container?

Both headline bugs are in how the server parses HTTP/2 frames. To use them, the attacker has to hold an HTTP/2 connection with the vulnerable process and control the frames on it.

A layer 7 proxy breaks that. It ends the client’s connection, reads complete requests, and opens its own connection to your container. There are three cases.

The proxy speaks HTTP/1.1 to the container. The HTTP/2 code is never executed on that path. This is the firm case.

The proxy speaks HTTP/2 to the container. The server’s HTTP/2 code runs, but the frames come from the proxy, not the attacker. Cloudflare says of its own service that “Your nginx only ever sees the requests Cloudflare chooses to send”, and that this holds for HTTP/2 origins because the proxy will not relay the volume of WINDOW_UPDATE frames the attack needs. Rapid7 says only that attacker-controlled frames “will likely not be retransmitted”. Wiz says it “depends on implementation”. We found no equivalent statement from AWS, Google or Microsoft about their load balancers, so count this as reduced exposure, not none. For Apache we would not rely on it at all: the flaw concerns concurrent streams, a multiplexing proxy also produces concurrent streams, and nobody has published the trigger.

The traffic is passed through at layer 4. The attacker’s own connection reaches the container. Fully exposed if the server negotiates HTTP/2.

Platform by platform

Where the container runs What reaches the container HTTP/2 bugs reachable from the internet?
AWS App Runner HTTP/1.0 or HTTP/1.1 No
ECS or Fargate behind an ALB, target group protocol version HTTP1 (the default) HTTP/1.1 No
ECS or Fargate behind an ALB, protocol version HTTP2 or GRPC HTTP/2 from the ALB Reduced. Patch first
ECS or Fargate behind a Network Load Balancer, or a task with a public IP The client’s own connection Yes, if HTTP/2 is on
Cloud Run (default) HTTP/1 No
Cloud Run with end-to-end HTTP/2 HTTP/2 cleartext (h2c) from Google’s front end Reduced. Patch first
Azure Container Apps, transport auto or http HTTP/1.1 from Envoy No
Azure Container Apps, transport http2 HTTP/2 from Envoy Reduced. Patch first
Azure Container Apps, transport tcp The client’s own connection Yes, if HTTP/2 is on

AWS

App Runner. The documentation is explicit: “App Runner provides support for HTTP 1.0 and HTTP 1.1 to the container instances.” TLS ends at App Runner. There is no setting that sends HTTP/2 to your container. Note that App Runner is closed to new customers, and AWS points them to ECS Express Mode.

ECS and Fargate behind an Application Load Balancer. “By default, Application Load Balancers send requests to targets using HTTP/1.1.” The ALB accepts HTTP/2 from browsers and converts. That changes only if someone set the target group’s protocol version to HTTP2 or GRPC. ECS Express Mode creates a Fargate service behind an ALB, so the same rule applies.

Network Load Balancers and public tasks. An NLB forwards the connection. So does a task with a public IP and an open security group. If nginx or Apache in that task negotiates HTTP/2, the attacker is talking to it directly.

CloudFront. The origin HTTP version defaults to HTTP/1.1, and HTTP/2 to the origin is an option. CloudFront only helps if the origin cannot be reached around it.

Elastic Beanstalk. AWS’s bulletin says of the platform’s own nginx: “The default configuration does not enable HTTP/2.” The 19 November platform release moved the Amazon Linux 2023 platforms to nginx 1.30.7.

Amazon Linux. Patched packages are out: ALAS2023-2026-3494 for nginx and ALAS2023-2026-3458 for httpd on Amazon Linux 2023, with matching advisories for Amazon Linux 2.

Azure

Container Apps. Microsoft’s announcement: “Container Apps ingress is built on Envoy, not nginx, so the platform’s built-in ingress is not affected.” Then: “Your own containers that run nginx are.” The ingress transport setting decides the protocol, as in the table above, and the default is auto. Microsoft’s instruction is blunt: “Patch in every case. Ingress settings do not replace the update.”

App Service. Microsoft’s documentation says: “App Service terminates TLS at the front ends.” The pages we read do not state which HTTP version the front end uses towards a custom container, so check the server’s own configuration as described below, and do not assume.

Google Cloud

Cloud Run. By default, “Cloud Run downgrades those requests from HTTP/2 to HTTP/1 with the exception of native gRPC traffic”. If you enabled end-to-end HTTP/2 (--use-http2, or a port named h2c), the container receives cleartext HTTP/2. Cloudflare’s testing found the nginx flow-control bug also faults over cleartext HTTP/2.

Application Load Balancer. The backend service protocol is whatever you chose: HTTP or HTTPS (both HTTP/1.1), HTTP/2 or H2C. The load balancer does not fall back to another.

Kubernetes on any of the three

On EKS, AKS and GKE the same logic applies to whatever sits in front of your pods. One extra item: the community ingress-nginx controller was retired in March 2026 and receives no further security patches, and its use-http2 option defaults to "true". If it is still your ingress, this is the week to set that to "false" and schedule the migration. GKE’s own platform does not use ingress-nginx.

What the platform does not cover

Traffic from inside. The proxy only filters the public path. Service-to-service calls, an internal load balancer, a peered network or a neighbouring container may reach the server directly. If HTTP/2 is enabled on it, an attacker with a foothold inside can use it.

The bugs that are not about HTTP/2. The resolver flaw arrives over ordinary HTTP/1.1 requests. It needs the resolver directive, which is common in container setups that look up upstream names at request time, combined with subrequests such as mirror. The alias with try_files overflow and Apache’s mod_md crash (CVE-2026-106023, httpd 2.4.30 to 2.4.70) are likewise untouched by protocol conversion.

The next configuration change. Someone switches a target group to gRPC, or moves a service behind an NLB, a year from now. The protection was a side effect, and nobody will remember it was load-bearing.

The host kernel. On serverless platforms the kernel belongs to the provider. We found no provider statement on the SCTP flaw at the time of writing.

Check your exposure

1. Find every copy. The obvious ones are services built on the nginx or httpd images. The ones that get missed are single-page frontends served from nginx:alpine, PHP images with a bundled web server, and sidecar proxies.

2. Read the server’s real configuration. Run these inside the running container, not on your laptop.

nginx -v
nginx -T 2>/dev/null | grep -nE 'listen .*(http2|quic)|http2 +on|http3 +on|resolver|mirror'
httpd -v
httpd -M 2>/dev/null | grep http2
grep -rnE '^\s*Protocols' /usr/local/apache2/conf /etc/httpd /etc/apache2 2>/dev/null

No http2 and no Protocols line with h2 or h2c means the headline bugs are not reachable in that container from anywhere. nginx’s http2 directive defaults to off. A resolver line together with mirror means the resolver flaw needs attention regardless.

3. Read the platform’s setting.

# AWS: HTTP1, HTTP2 or GRPC per target group
aws elbv2 describe-target-groups \
  --query 'TargetGroups[].[TargetGroupName,Protocol,ProtocolVersion]' --output table

# Google Cloud: http1 (default) or h2c
gcloud run services describe SERVICE --region REGION \
  --format='value(spec.template.spec.containers[0].ports[0].name)'

# Azure: auto, http, http2 or tcp
az containerapp ingress show -n APP -g RESOURCE_GROUP --query transport

4. Do not trust a test from outside. curl --http2 against your public hostname tells you what the provider’s proxy speaks, not what your container speaks.

Mitigate, in this order

1. Rebuild and redeploy. nginx 1.30.7 or 1.31.9. Apache httpd 2.4.71. Pull the base image fresh, build without cache, and roll a new deployment or revision. A patched image sitting in the registry protects nothing: the running tasks still hold the old binary. On a virtual machine, restart the service after upgrading. A reload does not replace the running executable.

2. Verify by package, not by version string. Distributions backport fixes without changing the upstream version. Debian fixed nginx in 1.22.1-9+deb12u11 for bookworm and 1.26.3-3+deb13u11 for trixie, both still reporting an “old” nginx version. Check the package version or the vendor’s advisory ID. The reverse also applies: an image pinned to an old digest stays vulnerable however current the host is.

3. If you cannot deploy today, turn HTTP/2 off at the server.

# nginx 1.25.1 and later; on older versions remove "http2" from the listen line
http2 off;
# every virtual host, not only the global section
Protocols http/1.1

Behind a proxy that already speaks HTTP/1.1 to you, this costs nothing. It does break native gRPC, and on nginx it addresses only the two HTTP/2 CVEs.

4. Make the provider’s proxy the only way in. No public IPs on tasks. A security group that accepts traffic only from the load balancer’s security group. Internal-only ingress for services that have no business being public.

5. Assume a worker can be compromised and limit what it holds. Run as a non-root user with a read-only root filesystem and no added capabilities. Give the task role only what the web tier needs. Keep database and API credentials out of the proxy container altogether. On hosts you manage yourself, Cloudflare suggests blocking the SCTP module with install sctp /bin/false under /etc/modprobe.d/ until a kernel fix exists.

6. Watch for the signs that exist. Repeated worker process exited on signal 11 lines, or worker_connections are not enough, reusing connections, deserve a look. CERT-EU cautions that crashes are not a reliable indicator of a successful attack. The stronger one is a web server process starting a program it has no reason to start.

The takeaway

A managed container platform did reduce exposure this month, mostly by converting HTTP/2 to HTTP/1.1 before the request reached the container. That is worth knowing, because it tells you which services to patch first: anything behind a Network Load Balancer, a TCP ingress, a public IP or an HTTP/2 backend setting.

It is not a reason to skip the rest. The platform patches its proxy. The image is yours. A base image is a dependency like any other, and the teams that had a quiet week were the ones who could rebuild and redeploy every container in an afternoon.

Related reading: the AWS baseline we run on every account, replacing stored keys with workload identity, and five questions directors should ask about cyber risk.

Sources

Written by

Pikabyte Engineering

Pikabyte builds custom business systems, applied AI and secure cloud infrastructure from Malaysia. Talk to us.

Start a conversation

Want this applied to your business?

Tell us what is slowing the business down. You will talk to an engineer, not a salesperson, and get a straight answer on whether software is the right fix.