Research • Detection • Reproduction • Defensive Validation
Security Research Project
Research driver and laboratory tooling for investigating the
assign_headers()allocator race in Apache HTTP Server's HTTP/2 implementation.The project focuses on reproducibility, allocator behavior, differential testing, sanitizer validation, detection and mitigation.
This repository is intended for:
- Authorized vulnerability research
- Local/dedicated laboratory environments
- Differential testing
- ASan/TSan validation
- Detection engineering
- Patch verification
- Defensive security research
Do not run corruption-oriented testing against systems you do not own or have explicit authorization to test.
The race is probabilistic and later corruption stages are highly dependent on process layout, allocator state and deployment configuration.
| Property | Value |
|---|---|
| CVE | CVE-2026-119618 |
| Component | Apache HTTP Server mod_http2 / mod_h2 |
| Class | CWE-362 |
| Severity | Critical |
| CVSS v3.1 | 9.8 |
| Attack Vector | Network |
| Authentication | None |
| User Interaction | None |
| Protocol | HTTP/2 / h2c |
| Affected httpd | 2.4.55 – 2.4.70 |
| Fixed httpd | 2.4.71 |
| Affected mod_h2 | 2.0.8 – 2.0.42 |
| Fixed mod_h2 | 2.0.43 |
The vulnerability is associated with the assign_headers() processing path in Apache's HTTP/2 implementation.
Under specific request-header conditions, a worker thread can modify a header table associated with a different memory-pool/allocator context than the request-private table.
The problematic operation is conceptually:
apr_table_setn(req->headers, "Content-Length", "0");while the corrected implementation writes to the request-private table:
apr_table_setn(r->headers_in, "Content-Length", "0");The distinction is important because the two tables can be backed by different allocator contexts.
When the target table is full, apr_table_setn() may grow the underlying entry array. Under concurrent allocator activity, this creates the synchronization-sensitive condition investigated by this project.
Network
│
▼
┌───────────────┐
│ HTTP/2 Client │
└───────┬───────┘
│
HEADERS / streams
│
▼
┌─────────────────────┐
│ Apache httpd │
│ mod_http2 / mod_h2 │
└──────────┬──────────┘
│
assign_headers()
│
┌──────────────┴──────────────┐
│ │
▼ ▼
request-private stream/connection
pool pool
│ │
▼ ▼
r->headers_in req->headers
│ │
│ │
│ allocator path
│ │
└──────────────┬──────────────┘
│
synchronization
boundary
│
▼
allocator behavior
│
┌────────┴────────┐
│ │
▼ ▼
Fixed Affected
version version
│ │
▼ ▼
safe execution race condition
The vulnerable code path resides in:
modules/http2/h2_request.c
assign_headers()
A simplified representation of the relevant logic is:
r->headers_in = apr_table_clone(r->pool, req->headers);
...
if (no_body) {
if (!cl && apr_table_get(req->headers, "Content-Type")) {
apr_table_setn(req->headers, "Content-Length", "0");
}
}The corrected implementation changes the destination:
- apr_table_setn(req->headers, "Content-Length", "0");
+ apr_table_setn(r->headers_in, "Content-Length", "0");This keeps the synthesized header within the request-private memory context.
The important distinction is allocator ownership.
Conceptually:
Request
│
├── r->pool
│ └── r->headers_in
│
└── stream pool
└── req->headers
│
└── connection allocator
The problematic path allows worker-side header processing to interact with the allocator associated with the stream/connection side.
The allocator's synchronization behavior therefore becomes relevant when concurrent allocation and release operations occur.
The affected behavior requires a specific combination of request properties.
At a high level:
- Request contains no body.
- HTTP/2
HEADERSframe terminates the stream. Content-Typeexists.Content-Lengthdoes not exist.- Header-table growth occurs.
- The relevant HTTP/2 processing path is reached.
- The request is not a
CONNECTrequest.
The exact allocation boundary is implementation-dependent and should be studied using a local instrumented build rather than inferred from network behavior alone.
The relevant table is initially created with a capacity similar to:
apr_table_make(pool, 10);Capacity grows geometrically:
10
│
└──► 20
│
└──► 40
│
└──► 80
│
└──► 160
│
└──► 320
HTTP/2 pseudo-headers are represented separately rather than stored as ordinary table entries.
The implementation also derives a Host entry from :authority.
This means allocation boundaries can be calculated deterministically for laboratory reproduction.
The project is organized around four stages.
┌──────────────────────────┐
│ 1. Behavioral validation │
└────────────┬─────────────┘
│
▼
┌──────────────────────────┐
│ 2. Differential testing │
│ affected vs fixed │
└────────────┬─────────────┘
│
▼
┌──────────────────────────┐
│ 3. Sanitizer analysis │
│ ASan / TSan │
└────────────┬─────────────┘
│
▼
┌──────────────────────────┐
│ 4. Defensive validation │
│ detection / mitigation│
└──────────────────────────┘
The recommended workflow is to validate each stage independently.
.
├── README.md
├── h2.py
├── groom.py
├── exploit.py
├── post.sh
└── build.sh
| File | Purpose |
|---|---|
README.md |
Documentation and research methodology |
h2.py |
HTTP/2 framing / HPACK research helpers |
groom.py |
Header-table and allocator-layout research helpers |
exploit.py |
Controlled laboratory race driver |
post.sh |
Post-corruption research scaffold |
build.sh |
Differential laboratory build helper |
The research tooling is designed around Python's standard library.
Python 3.x
No third-party Python packages are required.
python3 --versionThe HTTP/2 test environment supports:
h2c
TLS + ALPN h2
For reproducible research, build both an affected and a fixed Apache version.
Recommended topology:
┌─────────────────┐
│ Test Controller │
└────────┬────────┘
│
identical HTTP/2 traffic
│
┌────────────┴────────────┐
│ │
▼ ▼
┌──────────────┐ ┌──────────────┐
│ httpd 2.4.70 │ │ httpd 2.4.71 │
│ affected │ │ fixed │
└──────┬───────┘ └──────┬───────┘
│ │
▼ ▼
ASan/TSan ASan/TSan
│ │
└──────────┬─────────────┘
▼
Result comparison
Recommended starting environment:
CPU: 2 cores
Memory: 4 GB
MPM: prefork
Protocol: h2c + http/1.1
The strongest validation method is to send identical traffic to both versions.
Same traffic
│
┌──────────┴──────────┐
▼ ▼
2.4.70 2.4.71
affected fixed
│ │
▼ ▼
ASan/TSan ASan/TSan
│ │
└──────────┬──────────┘
▼
Compare reports
This reduces false positives caused by:
- unrelated application crashes
- allocator differences
- timing anomalies
- deployment-specific configuration
- backend failures
ASan is useful for identifying memory corruption and obtaining stack traces around allocator and pool operations.
Potentially relevant areas include:
allocator_lock
allocator_free
apr_palloc
run_cleanups
h2_stream_send_frame
output_buffered
The exact stack depends on build flags, APR version and runtime behavior.
TSan is particularly useful for the concurrency aspect.
A successful laboratory reproduction should be evaluated for:
data race
│
▼
shared allocator state
│
▼
assign_headers()
│
▼
concurrent allocation/free
The fixed version should be used as the control case.
There is no guaranteed unique network signature.
The relevant HTTP/2 traffic can resemble legitimate traffic.
Therefore, detection should be based on multiple signals.
Look for:
- Unexpected httpd child termination
- Repeated HTTP/2 connection resets
- Segmentation faults
- Worker restarts
- Abnormal crash frequency
- Repeated failures on h2-enabled listeners
Correlate:
access.log
error.log
system journal
process lifecycle
core dumps
container logs
with the time of anomalous HTTP/2 activity.
HTTP/2 listener
│
▼
Connection telemetry
│
▼
Repeated abnormal termination?
│
├── No ──► Normal monitoring
│
└── Yes
│
▼
Check error.log
│
▼
Check child crashes
│
▼
Check package version
│
▼
Check vendor advisory
│
▼
Patch / isolate / restart
The preferred mitigation is upgrading to the fixed Apache release:
httpd 2.4.71
or installing the appropriate vendor security update.
After upgrading, restart the affected Apache processes.
If patching is not immediately possible, HTTP/2 can be disabled as a temporary mitigation:
Protocols http/1.1Apply the configuration consistently, including virtual hosts that override protocol settings.
Trade-off: This disables HTTP/2 functionality and may affect application performance and compatibility.
Distribution packages can contain backported security fixes.
Therefore:
Do not rely solely on the upstream version string.
Verify the installed package revision and the vendor's security advisory.
Examples:
dnf list installed ea-apache24and:
apt policy ea-apache24For production environments, prefer the vendor's package security metadata.
During remediation, review:
HTTP/2 enablement
MPM configuration
worker process privileges
container isolation
SELinux/AppArmor policy
PHP-FPM socket permissions
virtual-host separation
filesystem permissions
A memory-corruption vulnerability in an Apache worker should not automatically be equated with root-level compromise.
Actual impact depends heavily on process privileges and isolation boundaries.
[ ] Identify Apache installations
[ ] Determine whether HTTP/2 is enabled
[ ] Check installed package revision
[ ] Compare against vendor advisory
[ ] Upgrade to fixed package
[ ] Restart Apache
[ ] Review error.log
[ ] Review crash/core-dump events
[ ] Investigate unusual HTTP/2 connection drops
[ ] Check application/backend logs
[ ] Verify HTTP/2 configuration
[ ] Confirm remediation in staging
[ ] Confirm remediation in production
This project should preferably be executed inside an isolated environment.
Recommended:
┌──────────────────────────────────────┐
│ Host System │
│ │
│ ┌────────────────────────────────┐ │
│ │ Isolated Lab │ │
│ │ │ │
│ │ vulnerable httpd │ │
│ │ fixed httpd │ │
│ │ ASan / TSan │ │
│ │ test client │ │
│ │ controlled network │ │
│ └────────────────────────────────┘ │
│ │
└──────────────────────────────────────┘
Prefer:
- isolated VM
- disposable containers where appropriate
- no production credentials
- no real customer data
- restricted network access
- snapshots before testing
- core dumps retained for analysis
The research results can vary significantly depending on:
- CPU topology
- scheduler behavior
- MPM configuration
- APR version
- allocator state
- memory layout
- HTTP/2 implementation details
- distribution patches
- compiler optimizations
- sanitizer configuration
Consequently, a result obtained on one build should not automatically be generalized to another.
| Stage | Status |
|---|---|
| Root-cause analysis | ✅ |
| Fixed-version comparison | ✅ |
| Header-table modeling | ✅ |
| Laboratory reproduction | 🔬 |
| Sanitizer validation | 🔬 |
| Race characterization | 🔬 |
| Detection research | 🔬 |
| Controlled corruption research | |
| Reliable public RCE | ❌ Not established |
| Version | Status | Recommended Action |
|---|---|---|
2.4.55 – 2.4.70 |
Potentially affected | Upgrade |
2.4.71+ |
Fixed upstream version | Keep updated |
| Vendor backport | Depends on package revision | Verify vendor advisory |
| HTTP/1.1-only | HTTP/2 path unavailable | No HTTP/2 exposure |
Apache HTTP Server Security Advisories
Relevant Apache changes:
2.4.x:
824beab9b9424d6cfb29595248fdbf6c3dddeab1
trunk:
5ed39287
Related Apache PRs:
apache/httpd#975
apache/httpd#977
Relevant APR sources:
memory/unix/apr_pools.c
tables/apr_tables.c
Research credit:
Anthropic OSS Scanner
ANT-2026-MAPKT6MZ
Anthony Weems
Simon Scannell
Google Cloud Vulnerability Research
This repository is intended for authorized security research, vulnerability validation and defensive testing.
Use only against systems for which you have explicit authorization.
The maintainers and contributors are not responsible for unauthorized use, service disruption, data loss or other consequences resulting from deployment outside an authorized research environment.
CVE-2026-119618 • Apache HTTP/2 Security Research