Skip to content

About

Weaponised PoC driver for CVE-2026-119618, the mod_http2 assign_headers() race: header-table shaping, allocator free-list priming, controlled heap overlap and a forged apr_table_entry_t layout with an RCE roadmap. httpd 2.4.55-2.4.70, stdlib-only.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

5 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 

Repository files navigation

CVE-2026-119618 — Apache httpd mod_http2 Race

Research • Detection • Reproduction • Defensive Validation

CVE CVSS Component Language Dependencies Status

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.


⚠️ Security Notice

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.


Vulnerability Overview

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

Executive Summary

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.


Architecture

                         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

Root Cause

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.


Why the Race Matters

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.


Trigger Conditions

The affected behavior requires a specific combination of request properties.

At a high level:

  • Request contains no body.
  • HTTP/2 HEADERS frame terminates the stream.
  • Content-Type exists.
  • Content-Length does not exist.
  • Header-table growth occurs.
  • The relevant HTTP/2 processing path is reached.
  • The request is not a CONNECT request.

The exact allocation boundary is implementation-dependent and should be studied using a local instrumented build rather than inferred from network behavior alone.


Header Table Model

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.


Research Methodology

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.


Repository Layout

.
├── 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

Requirements

The research tooling is designed around Python's standard library.

Python 3.x

No third-party Python packages are required.

python3 --version

The HTTP/2 test environment supports:

h2c
TLS + ALPN h2

Laboratory Environment

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

Differential Testing

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

Sanitizer Validation

AddressSanitizer

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.


ThreadSanitizer

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.


Detection

There is no guaranteed unique network signature.

The relevant HTTP/2 traffic can resemble legitimate traffic.

Therefore, detection should be based on multiple signals.

Server-side indicators

Look for:

- Unexpected httpd child termination
- Repeated HTTP/2 connection resets
- Segmentation faults
- Worker restarts
- Abnormal crash frequency
- Repeated failures on h2-enabled listeners

Operational correlation

Correlate:

access.log
error.log
system journal
process lifecycle
core dumps
container logs

with the time of anomalous HTTP/2 activity.


Example Defensive Monitoring Flow

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

Mitigation

1. Upgrade Apache

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.


2. Disable HTTP/2 Temporarily

If patching is not immediately possible, HTTP/2 can be disabled as a temporary mitigation:

Protocols http/1.1

Apply the configuration consistently, including virtual hosts that override protocol settings.

Trade-off: This disables HTTP/2 functionality and may affect application performance and compatibility.


Package Verification

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-apache24

and:

apt policy ea-apache24

For production environments, prefer the vendor's package security metadata.


Configuration Review

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.


Production Response Checklist

[ ] 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

Research Safety

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

Limitations

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.


Research Status

Stage Status
Root-cause analysis ✅
Fixed-version comparison ✅
Header-table modeling ✅
Laboratory reproduction 🔬
Sanitizer validation 🔬
Race characterization 🔬
Detection research 🔬
Controlled corruption research ⚠️ Experimental
Reliable public RCE ❌ Not established

Version Matrix

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

References

Apache HTTP Server

Apache HTTP Server Security Advisories

NVD

NVD — CVE-2026-119618

Red Hat

Red Hat — CVE-2026-119618

oss-security

Openwall oss-security


Upstream Fix

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

Credits

Research credit:

Anthropic OSS Scanner
ANT-2026-MAPKT6MZ

Anthony Weems
Simon Scannell

Google Cloud Vulnerability Research

License / Responsible Disclosure

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

About

Weaponised PoC driver for CVE-2026-119618, the mod_http2 assign_headers() race: header-table shaping, allocator free-list priming, controlled heap overlap and a forged apr_table_entry_t layout with an RCE roadmap. httpd 2.4.55-2.4.70, stdlib-only.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages