# Apache HTTP/2 vulnerability CVE-2026-119618: find every h2 line, upgrade to 2.4.71, check the running process

URL: https://systemdesignsimple.com/apache-http2-rce-check-and-fix/
Published: 2026-11-15
Category: Security
Publisher: System Design Simple (https://systemdesignsimple.com)

## Summary

The Apache HTTP/2 vulnerability CVE-2026-119618 is a critical mod_http2 flaw that can lead to RCE, per the Apache advisory of 2026-11-11. It affects httpd 2.4.55 through 2.4.70 with mod_http2 loaded and h2 or h2c enabled. Upgrade to 2.4.71 or your distro's fixed httpd and mod_http2 packages, restart fully and test each origin listener; until then remove h2 and h2c everywhere.

## Key facts

- **CVE:** CVE-2026-119618, rated critical by the Apache advisory of 2026-11-11: mod_http2 heap corruption and possible RCE in assign_headers
- **Affected:** per the Apache advisory of 2026-11-11: httpd 2.4.55 through 2.4.70; mod_h2 from GitHub 2.0.8 through 2.0.42
- **Fixed in:** per the Apache advisory of 2026-11-11: httpd 2.4.71, released 2026-11-11, commit 824beab
- **Exposure condition:** mod_http2 loaded and h2 or h2c in an effective Protocols line, server-wide or in any VirtualHost (Apache Protocols docs)
- **Our lab:** in our test on 2026-11-13: 15 synthetic config fixtures classified offline; 8 classified affected, all 8 classified patched or mitigated after upgrade or h2/h2c removal (one is a parser case), 7/7 normal fixtures unchanged; no httpd was run

The Apache HTTP/2 vulnerability CVE-2026-119618 is a critical mod_http2 flaw in Apache HTTP Server 2.4.55 through 2.4.70 that, according to the Apache advisory of 2026-11-11, can lead to remote code execution on a build that offers HTTP/2 (`h2` or `h2c`). Upgrade to 2.4.71 or your distro's fixed httpd and mod_http2 packages, do a full restart, and confirm the process serving traffic loaded the new build. If you cannot upgrade today, remove `h2` and `h2c` from every effective `Protocols` line.

This guide is for Apache servers you own or maintain.

| | CVE-2026-119618 (Apache advisory, 2026-11-11) |
|---|---|
| Component | mod_http2, `assign_headers()` in `h2_request.c` |
| Affected | httpd 2.4.55 through 2.4.70; mod_h2 (GitHub) 2.0.8 through 2.0.42 |
| Fixed | httpd 2.4.71, commit `824beab` |
| Workaround named | none |

## Am I affected? How do I check for the Apache HTTP/2 vulnerability?

You are affected when three things hold for the running server: the httpd or mod_http2 build is in the range without a distro backport, `http2_module` is loaded, and an effective `Protocols` line offers `h2` (HTTP/2 over TLS) or `h2c` (HTTP/2 over cleartext TCP). That line can sit in the main config, one `<VirtualHost>`, or a file pulled in by `Include` or `IncludeOptional`.

Run the dumps the way the service runs httpd: same executable, same `-f`, `-d` and `-D` arguments, same environment. Read those from the unit first. On Debian, `apachectl` loads `/etc/apache2/envvars` for you; a bare `apache2 -M` does not.

```sh
# how the service really starts httpd (RHEL: httpd instead of apache2)
systemctl cat apache2 | grep -E 'ExecStart|EnvironmentFile'

# version, loaded modules and include tree, with the service's arguments added
apachectl -v
apachectl -M 2>/dev/null | grep http2_module
apachectl -t -D DUMP_INCLUDES

# candidate Protocols lines in every included file
apachectl -t -D DUMP_INCLUDES 2>/dev/null | grep -oE '/[^ ]+$' | xargs grep -niE '^\s*protocols\s'
```

The grep finds candidates. A hit inside `<IfModule>` or `<IfDefine>` only counts when that condition is true for this service, so read each hit in its scope.

On packaged builds the module may not come from the httpd package. On RHEL, Rocky, Alma and Fedora, mod_http2 ships as its own [`mod_http2` package](https://packages.fedoraproject.org/pkgs/mod_http2/mod_http2/), so find the owner of the loaded `.so` and compare that revision with the distro advisory:

```sh
rpm -qf /usr/lib64/httpd/modules/mod_http2.so   # RHEL family: usually mod_http2-<rev>
rpm -q httpd mod_http2
dpkg -S mod_http2.so && dpkg-query -W apache2-bin   # Debian, Ubuntu: compare with the DSA/USN
apk info --who-owns /usr/lib/apache2/mod_http2.so   # Alpine: apache2-http2
```

## Fix it now: how do I patch CVE-2026-119618?

```sh
# Debian, Ubuntu
sudo apt-get update && sudo apt-get install --only-upgrade apache2 apache2-bin

# RHEL, Rocky, Alma, Fedora: upgrade both packages
sudo dnf upgrade httpd mod_http2

# Alpine
sudo apk upgrade apache2 apache2-http2

# source build or mod_h2 from GitHub: build httpd 2.4.71, or mod_h2 newer than 2.0.42
```

For the official container image, pulling changes nothing that is already running. Pull, recreate the container the way your deployment does it, then check inside the replacement:

```sh
docker pull httpd:2.4
# recreate: docker compose up -d, a rollout, or docker run with your usual flags
docker exec "$container_name" httpd -v     # want 2.4.71 or later
```

On a host, test the config and do a full stop and start. A [graceful restart](https://httpd.apache.org/docs/2.4/stopping.html) replaces the children but keeps the parent, which can keep the old binary mapped.

```sh
sudo apachectl -t && sudo systemctl restart apache2     # httpd on RHEL

pid=$(systemctl show -p MainPID --value apache2)
ps -o lstart=,args= -p "$pid"                        # start time later than the package install
sudo ls -l /proc/"$pid"/exe                          # "(deleted)" = stale binary still running
sudo grep -E '\.so.*\(deleted\)' /proc/"$pid"/maps   # stale modules
```

A `(deleted)` mapping means the process still runs files the package manager replaced. An empty result only means nothing stale is mapped. Whether the build is fixed comes from the package revision check above.

## Why it is dangerous: how does the mod_http2 header write go wrong?

An HTTP/2 stream is one request and response carried on a shared connection. mod_http2 reads each stream on the main connection and collects its headers into an `h2_request` allocated from the stream's pool ([`h2_stream.c` in 2.4.70](https://github.com/apache/httpd/blob/2.4.70/modules/http2/h2_stream.c)). An APR pool is the arena allocator that owns an httpd object's memory. The stream is then processed on a secondary connection, where [`c2_process()`](https://github.com/apache/httpd/blob/2.4.70/modules/http2/h2_c2.c) builds an ordinary `request_rec`.

`assign_headers()` does that hand-off. It first clones the stream's header table into `r->headers_in`, which the request owns. One later branch, for a request with a `Content-Type`, no `Content-Length` and no body, sets `Content-Length: 0`. In 2.4.70 that write went to `req->headers`, the table still owned by the stream. The [fix commit](https://github.com/apache/httpd/commit/824beab9b9424d6cfb29595248fdbf6c3dddeab1) points it at `r->headers_in`.

So request-side code changes stream-side state. [APR tables](https://apr.apache.org/docs/apr/1.7/group__apr__tables.html) have no locking, and adding an entry can allocate from the owning pool. The [advisory](https://httpd.apache.org/security/vulnerabilities_24.html) classifies this as concurrent use of a shared resource without proper synchronization and says it can lead to RCE, which here means a remote client's code running as the httpd worker user. It does not describe the corruption sequence, and we do not claim one.

## Reproduce

Our lab, [`apache-http2-check-lab`](https://github.com/systemdesignsimple/labs/blob/main/labs/security/apache-http2-check-lab/apache-http2-check-lab.mjs), classifies configurations; it never starts httpd or sends a request. It builds 15 throwaway hosts, each with a sample `httpd -v`, `apachectl -V` and `httpd.conf`, and follows `Include` into directories and wildcards. In our test on 2026-11-13 (Node 22.13.1, 305 ms), it classified all 8 synthetic in-range fixtures with h2 or h2c as affected, including h2 only inside vhost `*:8443` and h2c reached through `Include conf/extra`, a directory. No vulnerability reproduction was performed.

## Experiment

| fixture (version, setting) | before | after |
|---|---|---|
| 2.4.62, `Protocols h2 h2c http/1.1` | affected | patched (2.4.71) |
| 2.4.55 and 2.4.70 (Debian), h2 on | affected | patched |
| 2.4.66, h2 only in vhost `*:8443` | affected | mitigated |
| 2.4.64, `h2c` only | affected | mitigated |
| 2.4.58 / 2.4.60, h2 or h2c via `IncludeOptional` / `Include` | affected | mitigated |
| 2.4.65, `loadmodule HTTP2_module`, `H2` (parser case) | affected | mitigated |
| 2.4.71 and 2.4.72, h2 on | patched | patched |
| 2.4.62, module commented out, no or commented Protocols, or h2 without the module | mitigated | mitigated |
| 2.4.54, h2 on | outside | outside |

## Fix

Each "after" applies one change: the upgrade, or removing `h2` and `h2c` from every `Protocols` line. A half fix that dropped `h2` but kept `h2c` stayed affected, since `h2c` still reaches mod_http2.

## Report

| in our test on 2026-11-13 | result |
|---|---|
| synthetic fixtures classified affected | 8/8 (one parser case) |
| classified patched or mitigated after changes | 8/8 |
| control fixtures unchanged | 7/7 |
| vulnerability reproduction | none performed |
| this Mac | Apache 2.4.66, in range; mod_http2 not loaded, 0 vhosts with h2 or h2c: mitigated |

The lab never runs httpd, so it shows neither the race nor that 2.4.71 removes it; that rests on the advisory and the commit. Its parser lowercases module and protocol names, so the `HTTP2_module` fixture describes a config a real httpd would refuse to load: count 7 real configurations plus one parser case. The 2026-11-13 run also let the last `Protocols` line in a scope replace earlier ones, which httpd does not do; the lab code now adds them up. It reads files on disk, not the running process or distro changelogs.

## If you cannot update today: how do I verify HTTP/2 is disabled?

The advisory names no workaround. Turning HTTP/2 off reduces exposure, because no connection reaches mod_http2:

```apache
# main config AND every <VirtualHost>, including Include files
Protocols http/1.1
```

Repeated `Protocols` directives in one scope accumulate protocols. Adding `Protocols http/1.1` after `Protocols h2` leaves h2 enabled; edit or remove every earlier h2/h2c entry ([`set_protocols()` in core.c](https://github.com/apache/httpd/blob/2.4.70/server/core.c#L3794)).

Or unload the module (`sudo a2dismod http2` on Debian, or comment out `LoadModule http2_module`), then `apachectl -t`, a full restart, and `apachectl -M` showing no `http2_module`. Then test each origin listener directly, not through a CDN or proxy. `--resolve` keeps Host and SNI (the hostname a TLS client sends) correct; `--noproxy '*'` skips proxy variables.

```sh
# TLS: prints 2 before the change, 1.1 after
curl --noproxy '*' -sS -o /dev/null -w '%{http_version}\n' --http2 \
  --resolve app.example.com:443:10.0.0.5 https://app.example.com/; echo "exit $?"

# cleartext Upgrade: 2 before, 1.1 after
curl --noproxy '*' -sS -o /dev/null -w '%{http_version}\n' --http2 \
  --resolve app.example.com:80:10.0.0.5 http://app.example.com/; echo "exit $?"

# direct h2c (prior knowledge): 2 before; after, expect a failed transfer and a nonzero exit
curl --noproxy '*' -sS -o /dev/null -w '%{http_version}\n' --http2-prior-knowledge \
  --resolve app.example.com:80:10.0.0.5 http://app.example.com/; echo "exit $?"
```

The direct test sends HTTP/2 with no HTTP/1.1 step, so a server without h2c answers it with an error rather than `1.1` ([curl docs](https://curl.se/docs/manpage.html#--http2-prior-knowledge)). [`H2Upgrade` and `H2Direct`](https://httpd.apache.org/docs/2.4/mod/mod_http2.html) control the two cleartext paths separately, so run both. A connection refused or certificate error is inconclusive. If the before-run already prints 1.1, check `curl -V | grep HTTP2`.

## Timeline and sources

| Date | Event |
|---|---|
| 2026-10-26 | reported to the Apache security team (advisory credit: Anthropic's OSS Scanner) |
| 2026-11-03 | reported again (advisory credit: Google Cloud Vulnerability Research) |
| 2026-11-11 | fixed by commit `824beab`; 2.4.71 released |
| 2026-11-12 | news coverage ([The Hacker News](https://thehackernews.com/2026/11/critical-apache-http2-flaw-could-let.html)) |
| 2026-11-13 | our lab run |

For holding a fixed release you cannot deploy yet, the [OWASP Vulnerable Dependency Management cheat sheet](https://cheatsheetseries.owasp.org/cheatsheets/Vulnerable_Dependency_Management_Cheat_Sheet.html) covers the cases. Directive details are in the [Protocols](https://httpd.apache.org/docs/2.4/mod/core.html#protocols) docs.

## Our take

`assign_headers()` clones the stream's headers so the request owns private state, then one write goes to the original. The `const` on `req` did not catch it, because the table pointer inside the struct is not const. If you maintain C modules that hand data between threads, search for writes through the source struct after a clone.

On RHEL-family hosts, `httpd -v` and `rpm -q httpd` describe one package while the vulnerable code can live in another. A ticket that checks only the server version can close with the module unchanged. We would close it only when the package owning the loaded `mod_http2.so` matches the distro advisory and the restarted PID shows no stale mappings.

Our own lab got httpd's parsing wrong in two places. Any config scanner carries that risk, since its verdicts depend on how closely it copies the server's parser. We now start from `DUMP_INCLUDES`, the include tree httpd resolves itself, and end with a direct curl to each origin listener. The [OpenSSH bypass check](/openssh-long-password-auth-bypass-check/) used the same `/proc` step, the [Apache OFBiz check](/apache-ofbiz-rce-check-and-fix/) found a version file that could not tell patched from unpatched, and the [Node.js Brotli check](/nodejs-brotli-rce-check-and-fix/) follows the same order.

## Frequently asked questions

**My distro still shows 2.4.62 after updating. Is the Apache HTTP/2 vulnerability patched?**
Possibly. A backport is a fix copied into an older upstream version, so Debian, Ubuntu and RHEL can ship it under the same 2.4.x number. Compare the installed revision of the package that owns mod_http2.so with your distro's advisory for CVE-2026-119618, then confirm the restarted service loaded it.

**Is a graceful restart enough after upgrading httpd for CVE-2026-119618?**
Use a full stop and start. A graceful restart keeps the parent process, so on Linux the parent can still map the replaced binary. A deleted executable or .so in /proc/<pid>/maps is a sign of stale code; its absence alone does not prove the build is fixed.

**HTTP/2 ends at a TLS proxy in front of httpd. Is my Apache affected?**
Only if httpd itself offers h2 or h2c. Test the origin listener directly from the proxy host, with the real Host and SNI, in TLS, Upgrade and prior-knowledge modes. A test through the proxy only shows what the proxy speaks.

## Sources

- [Apache HTTP Server 2.4 vulnerabilities (official advisory, CVE-2026-119618 fixed in 2.4.71)](https://httpd.apache.org/security/vulnerabilities_24.html)
- [apache/httpd commit 824beab: mod_http2 assign_headers update table](https://github.com/apache/httpd/commit/824beab9b9424d6cfb29595248fdbf6c3dddeab1)
- [Apache HTTP Server documentation: mod_http2 (H2Direct, H2Upgrade)](https://httpd.apache.org/docs/2.4/mod/mod_http2.html)
- [Apache HTTP Server documentation: the Protocols directive](https://httpd.apache.org/docs/2.4/mod/core.html#protocols)
- [Fedora packages: mod_http2 (shipped separately from httpd)](https://packages.fedoraproject.org/pkgs/mod_http2/mod_http2/)
- [The Hacker News, 2026-11-12: critical Apache HTTP/2 flaw](https://thehackernews.com/2026/11/critical-apache-http2-flaw-could-let.html)
- [OWASP Cheat Sheet Series: Vulnerable Dependency Management](https://cheatsheetseries.owasp.org/cheatsheets/Vulnerable_Dependency_Management_Cheat_Sheet.html)
