Skip to content
KitploitKITPLOIT
도구익스플로잇블로그
Log in
제출
도구익스플로잇블로그
제출

해킹, 침투 테스트 및 사이버 보안 도구를 당신의 보안 무기고에!

Kitploit은 해킹, 사이버 보안 및 침투 테스트 도구 디렉토리입니다. 최신 프로젝트 업데이트를 발견하여 취약점을 찾고, 시스템을 분석하고, 테스트를 자동화하고, 보안을 강화하세요.

피드문의개인정보© 2026 Kitploit

도구 디렉토리

카테고리

모든 카테고리 보기
Loading categories
도구/GitHubGitHub/googlesky/cve-2026-119618
Web Vulnerability ScannersContainer SecurityDynamic Analysis (Sandboxing)ExploitationWeb SecurityFuzzingPapers & ResearchLabs & Practice
GitHubgooglesky/cve-2026-119618

CVE-2026-119618

Containerised differential lab and stdlib HTTP/2 PoC for CVE-2026-119618, a mod_http2 allocator race causing heap corruption in Apache httpd 2.4.55-2.4.70, with ASan/TSan evidence.

1471일 전아직 검토되지 않음
저장소 보기

인기

모두 보기 →

커뮤니티에서 가장 많이 사용되는 도구를 찾아보세요.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 궁극의 OSINT 툴킷: 조사 그래프, 신뢰도 점수 산정, 별칭 패밀리, 지도, 타임라인 및 보고서. 49개 모듈, 400개 이상 사이트, API 키 불필요.

    1.1k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # GhostLock 원탭 실행 앱 (CVE-2026-43499)

    601
  • 3

    looking-glass

    anonghosty/looking-glass

    Shadowserver 보고서를 MongoDB로 수집하고 이를 대화형 지도, 분석, 발견 사항, 권고 및 경영진 대시보드로 재생하는 CSIRT 플랫폼입니다.

    403
  • 4

    ARTEX

    baarai/artex

    LLM 멀티 에이전트 자율 침투 테스트 플랫폼으로, 플래너/워커 에이전트, 자산 및 탐색 그래프, MITM 트래픽 기록, 취약점 재테스트 기능을 제공합니다.

    319
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI 네이티브 사이버보안을 위한 행동 체계—의도가 통제된 실행이 되고, 증거가 운영 메모리가 되며, 모든 운영이 다음 운영을 개선하는 곳.

    265
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    웹 전반에서 7,700개 이상의 소셜 미디어 신원을 발견하고 매핑하는 AI 기반 OSINT 엔진

    263

모든 도구 탐색

도구 컬렉션을 둘러보세요

모든 도구 보기 →
공유
요청한 언어로 콘텐츠를 사용할 수 없습니다. 영어 버전을 표시합니다.

CVE-2026-119618 — Apache httpd mod_http2 heap corruption in assign_headers()

CVECVE-2026-119618
ComponentApache HTTP Server, module mod_http2 (standalone mod_h2)
Affectedhttpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42
Fixed inhttpd 2.4.71 · mod_h2 2.0.43
CWECWE-362 — Concurrent Execution using Shared Resource with Improper Synchronization
ImpactHeap corruption in an httpd child process; potential remote code execution
VectorNetwork, unauthenticated, HTTP/2 (cleartext h2c or TLS h2)
TriggerA body-less HTTP/2 request carrying Content-Type and no Content-Length, with the request header table filled to capacity
Fix commit824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick of trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3)
Upstream PRapache/httpd#975 → apache/httpd#977, merged 2026-11-09
CreditAnthropic's OSS Scanner (ANT-2026-MAPKT6MZ); Anthony Weems and Simon Scannell, Google Cloud Vulnerability Research
Advisoryhttps://httpd.apache.org/security/vulnerabilities_24.html
Workaroundremove h2 and h2c from the Protocols directive
Repositoryhttps://github.com/googlesky/CVE-2026-119618

mod_http2 gives every HTTP/2 stream a pool of its own, and that pool inherits the allocator of the connection that owns the session. The allocator has no mutex: apr_allocator_create() does not create one, so allocator_lock() is a no-op for the whole connection. Request processing is deliberately moved to worker threads with a private allocator (c2_transit_create()) precisely so that a worker never touches the connection's allocator. assign_headers() breaks that invariant: for a body-less request that carries Content-Type and no Content-Length, the worker writes the synthesised Content-Length: 0 into the shared stream table instead of the request-private r->headers_in. When the table is full, that write allocates a new 8 KB node from the connection's lock-free allocator while the connection thread is allocating from or freeing to the same free list. Two threads can pop the same node, and the resulting double ownership corrupts the heap of the httpd child process.

This repository contains a containerised differential laboratory that reproduces the corruption on httpd 2.4.70, proves the race with ThreadSanitizer, shows httpd 2.4.71 clean under the same traffic, exercises every sibling request shape, verifies the published workaround, and records a 0-day sweep on the fixed line.


1. Root cause

1.1 The affected code

modules/http2/h2_request.c, Apache httpd 2.4.70, assign_headers(). Line numbers are from the 2.4.70 release tarball.

320: static void assign_headers(request_rec *r, const h2_request *req,
321:                            int no_body, int is_connect)
322: {
323:     const char *cl;
324:
325:     r->headers_in = apr_table_clone(r->pool, req->headers);
...
341:     /* Unless we open a byte stream via CONNECT, apply content-length guards. */
342:     if (!is_connect) {
343:         cl = apr_table_get(req->headers, "Content-Length");
344:         if (no_body) {
345:             if (!cl && apr_table_get(req->headers, "Content-Type")) {
346:                 /* If we have a content-type, but already seen eos, no more
347:                  * data will come. Signal a zero content length explicitly.
348:                  */
349:                 apr_table_setn(req->headers, "Content-Length", "0");
350:             }
351:         }

The fix in 2.4.71 changes one line:

-                apr_table_setn(req->headers, "Content-Length", "0");
+                apr_table_setn(r->headers_in, "Content-Length", "0");

r->headers_in is the clone created on line 325 in r->pool, the request pool owned by the worker thread. req->headers is the stream's table, allocated from the stream pool and reachable by the connection thread.

1.2 The stream pool shares the connection's lock-free allocator

h2_session_open_stream() (h2_session.c:117) creates the per-stream pool as a child of the session pool and tags it:

apr_pool_create(&stream_pool, session->pool);
apr_pool_tag(stream_pool, "h2_stream");
stream = h2_stream_create(stream_id, stream_pool, session, ...);

The session pool is a descendant of the connection pool that the MPM creates in child_main() (server/mpm/prefork/prefork.c:423). That pool's allocator comes from apr_allocator_create(), and no mutex is ever set on it:

/* memory/unix/apr_pools.c:164 */
static APR_INLINE void allocator_lock(apr_allocator_t *allocator)
{
#if APR_HAS_THREADS
    if (allocator->mutex)              /* NULL for the MPM allocator */
        apr_thread_mutex_lock(allocator->mutex);
#endif
}

Request processing, on the other hand, is explicitly designed to avoid that allocator. c2_transit_create() (h2_mplx.c:210) gives every worker a private allocator:

    /* We create a pool with its own allocator to be used for
     * processing a request. This is the only way to have the processing
     * independent of its parent pool in the sense that it can work in
     * another thread.
     */
    rv = apr_allocator_create(&allocator);

The worker's request_rec is created on c2->pool, a descendant of the transit pool, so every allocation the worker normally makes is private. The vulnerable write is the exception: it allocates from the stream pool, whose allocator is the connection's.

1.3 The write only allocates when the header table is full

apr_table_setn() on an absent key falls through to apr_table_add(), which calls table_push() → apr_array_push_noclear() (tables/apr_tables.c:126):

if (arr->nelts == arr->nalloc) {
    int new_size = arr->nalloc <= 0 ? 1 : 2 * arr->nalloc;
    apr_table_entry_t *new_elts = apr_palloc(arr->pool, elt_size * new_size);
    ...
}

The table is created by h2_request_create() as apr_table_make(pool, 10), so nalloc starts at 10 and doubles: 10, 20, 40, 80, 160. Pseudo-headers are not stored in the table — they become req->method, req->scheme, req->authority and req->path. h2_request_end_headers() (h2_request.c:212) adds exactly one Host entry.

A request with 79 regular headers therefore holds 79 entries, Host makes 80, and nelts == nalloc == 80 when assign_headers() runs. The vulnerable apr_table_setn() grows the array to 160 entries:

160 * sizeof(apr_table_entry_t) = 160 * 24 = 3840 bytes

allocator_align() (apr_pools.c:268) rounds that to MIN_ALLOC (8192), so the write requests a fresh 8 KB node from the stream pool's allocator whenever the pool's active node has less than 3840 bytes left. That is the allocation that races.

1.4 The race

allocator_alloc() (apr_pools.c:289) walks the free-node list (allocator->free[index], allocator->max_index) and pops a node; allocator_free() (apr_pools.c:426) pushes one back and rewrites max_index. With no mutex, these are unsynchronised read-modify-write sequences over the same apr_allocator_t — a 200-byte heap object allocated by apr_allocator_create() in child_main(). Two threads can pop the same node, after which two different pools hand out overlapping memory.

ThreadSanitizer captures exactly this on 2.4.70 (evidence/tsan-vulnerable.txt):

도구 다운로드