From 98fa6bd2a7f2136fff9185de2ec18cb01dcde1fa Mon Sep 17 00:00:00 2001 From: Arturo Bernal Date: Wed, 11 Nov 2026 20:02:37 +0100 Subject: [PATCH 1/2] mod_proxy_fcgi, mod_brotli: Fix NULL deref when a FastCGI backend sends data after its own premature, stream-ending empty FCGI_STDOUT record. Some backends (PHP-FPM hitting PHP bug #72185, for one) emit a zero-length FCGI_STDOUT record too early and keep sending STDOUT data afterwards. mod_proxy_fcgi treated the empty record as end of stream, sent an EOS bucket down the filter chain, but kept forwarding the backend's later STDOUT data as if it were new content. A filter that tears down internal state on EOS and never removes itself from the chain -- mod_brotli's encoder, in this case -- gets invoked again with that stale state and crashes. Discard FastCGI STDOUT data received after the stream-ending record instead of forwarding it, and have mod_brotli remove itself from the output filter chain once it has seen EOS so it can never be invoked again for the same request regardless of the cause. PR: https://bz.apache.org/bugzilla/show_bug.cgi?id=66168 --- docs/log-message-tags/next-number | 2 +- modules/filters/mod_brotli.c | 8 ++ modules/proxy/mod_proxy_fcgi.c | 26 +++++ test/modules/proxy/env.py | 4 +- test/modules/proxy/fcgi_faker.py | 140 +++++++++++++++++++++++++ test/modules/proxy/test_08_fcgi_eos.py | 100 ++++++++++++++++++ 6 files changed, 277 insertions(+), 3 deletions(-) create mode 100644 test/modules/proxy/fcgi_faker.py create mode 100644 test/modules/proxy/test_08_fcgi_eos.py diff --git a/docs/log-message-tags/next-number b/docs/log-message-tags/next-number index 5d1df1abb36..0a29e80c5e8 100644 --- a/docs/log-message-tags/next-number +++ b/docs/log-message-tags/next-number @@ -1 +1 @@ -10687 +10703 diff --git a/modules/filters/mod_brotli.c b/modules/filters/mod_brotli.c index 0f7d770b670..0fc8a12c632 100644 --- a/modules/filters/mod_brotli.c +++ b/modules/filters/mod_brotli.c @@ -497,6 +497,14 @@ static apr_status_t compress_filter(ap_filter_t *f, apr_bucket_brigade *bb) } if (APR_BUCKET_IS_EOS(e)) { + /* The encoder state is about to be destroyed below. Remove + * ourselves from the filter chain now so that we can never be + * invoked again for this request, even if more data follows + * the EOS bucket (e.g. a backend forwarding data past the end + * of its own output stream through mod_proxy_fcgi; PR66168). + */ + ap_remove_output_filter(f); + rv = flush(ctx, BROTLI_OPERATION_FINISH, f); if (rv != APR_SUCCESS) { return rv; diff --git a/modules/proxy/mod_proxy_fcgi.c b/modules/proxy/mod_proxy_fcgi.c index f9b28dc7889..637da64bedf 100644 --- a/modules/proxy/mod_proxy_fcgi.c +++ b/modules/proxy/mod_proxy_fcgi.c @@ -601,6 +601,7 @@ static apr_status_t dispatch(proxy_conn_rec *conn, proxy_dir_conf *conf, { apr_bucket_brigade *ib, *ob; int seen_end_of_headers = 0, done = 0, ignore_body = 0; + int seen_stdout_eos = 0, warned_stdout_after_eos = 0; apr_status_t rv = APR_SUCCESS; int script_error_status = HTTP_OK; conn_rec *c = r->connection; @@ -815,6 +816,29 @@ static apr_status_t dispatch(proxy_conn_rec *conn, proxy_dir_conf *conf, switch (type) { case AP_FCGI_STDOUT: + if (seen_stdout_eos) { + /* The backend already signalled the end of its STDOUT + * stream with a zero-length record, and we already + * passed an EOS bucket down the output filter chain + * because of it. Some backends (e.g. PHP-FPM, see + * PHP bug #72185) can emit such a record too early and + * keep sending STDOUT data afterwards; discard it + * rather than forwarding more data past the EOS we + * already sent (PR66168). */ + if (!warned_stdout_after_eos) { + ap_log_rerror(APLOG_MARK, APLOG_WARNING, 0, r, APLOGNO(10702) + "Ignoring FastCGI STDOUT data received " + "after the backend already signalled " + "the end of its output stream"); + warned_stdout_after_eos = 1; + } + if (clen > readbuflen) { + clen -= readbuflen; + goto recv_again; + } + break; + } + if (clen != 0) { b = apr_bucket_transient_create(iobuf, readbuflen, @@ -942,6 +966,8 @@ static apr_status_t dispatch(proxy_conn_rec *conn, proxy_dir_conf *conf, } else { /* XXX what if we haven't seen end of the headers yet? */ + seen_stdout_eos = 1; + if (script_error_status == HTTP_OK) { b = apr_bucket_eos_create(c->bucket_alloc); APR_BRIGADE_INSERT_TAIL(ob, b); diff --git a/test/modules/proxy/env.py b/test/modules/proxy/env.py index b04ac748e61..5488d5e473f 100644 --- a/test/modules/proxy/env.py +++ b/test/modules/proxy/env.py @@ -82,8 +82,8 @@ def __init__(self, env: 'HttpdTestEnv'): super().__init__(env=env) self.add_source_dir(os.path.dirname(inspect.getfile(ProxyTestSetup))) self.add_modules(["proxy", "proxy_http", "proxy_ajp", "proxy_balancer", - "proxy_connect", "proxy_uwsgi", "lbmethod_byrequests", - "remoteip"]) + "proxy_connect", "proxy_uwsgi", "proxy_fcgi", + "lbmethod_byrequests", "remoteip", "brotli"]) self.add_optional_modules(["proxy_hcheck"]) diff --git a/test/modules/proxy/fcgi_faker.py b/test/modules/proxy/fcgi_faker.py new file mode 100644 index 00000000000..b4c1249f238 --- /dev/null +++ b/test/modules/proxy/fcgi_faker.py @@ -0,0 +1,140 @@ +""" +Minimal fake FastCGI responder backend for testing mod_proxy_fcgi. + +Listens on a TCP port and speaks the FastCGI wire protocol (records only, +no multiplexing). It reads and discards FCGI_BEGIN_REQUEST, FCGI_PARAMS +and FCGI_STDIN, then writes back an intentionally malformed FCGI_STDOUT +stream: a normal chunk of body data, followed by a zero-length FCGI_STDOUT +record (which per the FastCGI spec marks the end of the stream), followed +by *more* FCGI_STDOUT data. Some backends (PHP-FPM hitting PHP bug #72185, +for one) really do this, and the extra data after the stream-ending empty +record must be discarded rather than forwarded down the output filter +chain (see PR66168). +""" +import socket +import struct +import threading + + +FCGI_BEGIN_REQUEST = 1 +FCGI_END_REQUEST = 3 +FCGI_PARAMS = 4 +FCGI_STDIN = 5 +FCGI_STDOUT = 6 + +HEADER_LEN = 8 + +BODY_BEFORE_EOS = b"before-eos-" * 200 +BODY_AFTER_EOS = b"after-eos-" * 200 + + +def _recv_exact(conn, n): + buf = b"" + while len(buf) < n: + chunk = conn.recv(n - len(buf)) + if not chunk: + return None + buf += chunk + return buf + + +def _recv_record_header(conn): + header = _recv_exact(conn, HEADER_LEN) + if header is None: + return None + _version, rtype, req_id, content_len, pad_len = struct.unpack( + ">BBHHB", header[:7]) + return rtype, req_id, content_len, pad_len + + +def _recv_record(conn): + """Read one complete FastCGI record, returning (type, req_id, content).""" + hdr = _recv_record_header(conn) + if hdr is None: + return None + rtype, req_id, content_len, pad_len = hdr + content = _recv_exact(conn, content_len) if content_len else b"" + if content is None: + return None + if pad_len: + if _recv_exact(conn, pad_len) is None: + return None + return rtype, req_id, content + + +def _send_record(conn, rtype, req_id, content=b""): + header = struct.pack(">BBHHBB", 1, rtype, req_id, len(content), 0, 0) + conn.sendall(header + content) + + +def _handle(conn): + try: + begin = _recv_record(conn) + if begin is None or begin[0] != FCGI_BEGIN_REQUEST: + return + req_id = begin[1] + + # Drain FCGI_PARAMS until the stream-ending empty record. + while True: + rec = _recv_record(conn) + if rec is None: + return + if rec[0] == FCGI_PARAMS and len(rec[2]) == 0: + break + + # Drain FCGI_STDIN until the stream-ending empty record. + while True: + rec = _recv_record(conn) + if rec is None: + return + if rec[0] == FCGI_STDIN and len(rec[2]) == 0: + break + + headers = b"Content-Type: text/plain\r\n\r\n" + _send_record(conn, FCGI_STDOUT, req_id, headers + BODY_BEFORE_EOS) + + # Premature stream-ending empty record (the PHP-FPM / PHP bug + # #72185 pattern), immediately followed by more STDOUT data that + # must never reach an output filter chain that already saw EOS. + _send_record(conn, FCGI_STDOUT, req_id, b"") + _send_record(conn, FCGI_STDOUT, req_id, BODY_AFTER_EOS) + + _send_record(conn, FCGI_STDOUT, req_id, b"") + _send_record(conn, FCGI_END_REQUEST, req_id, + struct.pack(">LBxxx", 0, 0)) + finally: + conn.close() + + +class FcgiFaker: + """Fake FastCGI backend running in a daemon thread.""" + + def __init__(self, port: int): + self._port = port + self._done = False + self._sock = None + self._thread = None + + def start(self): + self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + self._sock.bind(("127.0.0.1", self._port)) + self._sock.listen(16) + self._thread = threading.Thread(target=self._serve, daemon=True) + self._thread.start() + + def stop(self): + self._done = True + try: + self._sock.close() + except OSError: + pass + + def _serve(self): + while not self._done: + try: + conn, _ = self._sock.accept() + except OSError: + break + t = threading.Thread(target=_handle, args=(conn,), daemon=True) + t.start() diff --git a/test/modules/proxy/test_08_fcgi_eos.py b/test/modules/proxy/test_08_fcgi_eos.py new file mode 100644 index 00000000000..ea91ed9b742 --- /dev/null +++ b/test/modules/proxy/test_08_fcgi_eos.py @@ -0,0 +1,100 @@ +""" +Tests for PR66168 / BZ 66168: a FastCGI backend that sends a premature, +stream-ending zero-length FCGI_STDOUT record and then keeps sending more +STDOUT data afterwards (as PHP-FPM does when hitting PHP bug #72185) must +not crash the worker. The extra data has to be discarded, not forwarded +down an output filter chain that already received the EOS bucket. +""" +import subprocess + +import pytest + +from pyhttpd.conf import HttpdConf +from .fcgi_faker import FcgiFaker, BODY_BEFORE_EOS, BODY_AFTER_EOS + + +FCGI_PORT = 5210 + + +def _curl_decodes_brotli(env): + """Whether curl can decode a brotli response (--compressed), which + depends on how it was built: not all CI curls can.""" + try: + out = subprocess.run([env.curl, "-V"], capture_output=True, + text=True, timeout=10).stdout + except (OSError, subprocess.SubprocessError): + return False + for line in out.splitlines(): + if line.startswith("Features:"): + return "brotli" in line.split() + return False + + +@pytest.fixture(autouse=True, scope="class") +def _proxy_fcgi_eos_setup(env): + faker = FcgiFaker(port=FCGI_PORT) + faker.start() + + # The backend deliberately sends data after its own stream-ending + # record; mod_proxy_fcgi logs AH10702 once per request when it + # discards that data instead of crashing on it. + env.httpd_error_log.add_ignored_lognos(["AH10702"]) + + conf = HttpdConf(env) + conf.start_vhost( + domains=[env.d_reverse], + port=env.http_port, + with_ssl=False, + ) + conf.add([ + "LogLevel proxy_fcgi:debug", + f"ProxyPass /fcgitest fcgi://127.0.0.1:{FCGI_PORT}/", + "AddOutputFilterByType BROTLI_COMPRESS text/plain", + ]) + conf.end_vhost() + conf.install() + + assert env.apache_restart() == 0 + + yield + + faker.stop() + + +class TestProxyFcgiEos: + + def test_proxy_08_001(self, env): + """A premature empty FCGI_STDOUT record followed by more backend + data must not crash the worker, even with a compressing output + filter (mod_brotli) in the chain.""" + url = f"http://{env.d_reverse}:{env.http_port}/fcgitest" + r = env.curl_raw(url, options=["-H", "Accept-Encoding: br"]) + assert r.exit_code == 0 + assert r.response["status"] == 200 + assert r.response["header"]["content-encoding"] == "br" + assert len(r.response["body"]) > 0 + + # Check the content too where curl can decode it: everything up + # to the premature EOS must have reached the client, but nothing + # the backend sent after it. + if _curl_decodes_brotli(env): + r = env.curl_raw(url, options=["--compressed", + "-H", "Accept-Encoding: br"]) + assert r.exit_code == 0 + assert r.response["status"] == 200 + assert BODY_BEFORE_EOS.decode() in r.stdout + assert BODY_AFTER_EOS.decode() not in r.stdout + + # No segfault (or any other unexpected error/warning, e.g. AH00051) + # was logged for this request: the package-scoped teardown asserts + # env.check_error_log() sees nothing unaccounted for. + + def test_proxy_08_002(self, env): + """The server (and this backend route) still answers normally + after handling the malformed backend response above.""" + r = env.curl_raw( + f"http://{env.d_reverse}:{env.http_port}/fcgitest") + assert r.exit_code == 0 + assert r.response["status"] == 200 + assert BODY_BEFORE_EOS.decode() in r.stdout + assert BODY_AFTER_EOS.decode() not in r.stdout From 10dfd60909cb7b2317c1bd7477c500b107e8e07d Mon Sep 17 00:00:00 2001 From: Arturo Bernal Date: Wed, 11 Nov 2026 20:03:37 +0100 Subject: [PATCH 2/2] mod_proxy_fcgi, mod_brotli: Add changes-entries/66168.txt --- changes-entries/66168.txt | 4 ++++ test/modules/proxy/env.py | 6 +++--- test/modules/proxy/test_08_fcgi_eos.py | 7 +++++++ 3 files changed, 14 insertions(+), 3 deletions(-) create mode 100644 changes-entries/66168.txt diff --git a/changes-entries/66168.txt b/changes-entries/66168.txt new file mode 100644 index 00000000000..9009215c5b5 --- /dev/null +++ b/changes-entries/66168.txt @@ -0,0 +1,4 @@ + *) mod_proxy_fcgi, mod_brotli: Fix a NULL pointer dereference (worker + crash) triggered by a FastCGI backend that sends a premature, + stream-ending empty FCGI_STDOUT record and keeps sending data + afterwards. PR 66168 [Arturo Bernal] diff --git a/test/modules/proxy/env.py b/test/modules/proxy/env.py index 5488d5e473f..cc5ed0a6606 100644 --- a/test/modules/proxy/env.py +++ b/test/modules/proxy/env.py @@ -82,9 +82,9 @@ def __init__(self, env: 'HttpdTestEnv'): super().__init__(env=env) self.add_source_dir(os.path.dirname(inspect.getfile(ProxyTestSetup))) self.add_modules(["proxy", "proxy_http", "proxy_ajp", "proxy_balancer", - "proxy_connect", "proxy_uwsgi", "proxy_fcgi", - "lbmethod_byrequests", "remoteip", "brotli"]) - self.add_optional_modules(["proxy_hcheck"]) + "proxy_connect", "proxy_uwsgi", + "lbmethod_byrequests", "remoteip"]) + self.add_optional_modules(["proxy_hcheck", "proxy_fcgi", "brotli"]) class ProxyTestEnv(HttpdTestEnv): diff --git a/test/modules/proxy/test_08_fcgi_eos.py b/test/modules/proxy/test_08_fcgi_eos.py index ea91ed9b742..53daf99b5c5 100644 --- a/test/modules/proxy/test_08_fcgi_eos.py +++ b/test/modules/proxy/test_08_fcgi_eos.py @@ -32,6 +32,13 @@ def _curl_decodes_brotli(env): @pytest.fixture(autouse=True, scope="class") def _proxy_fcgi_eos_setup(env): + env.require(env.has_shared_module("proxy_fcgi"), "mod_proxy_fcgi not available", + dep="mod_proxy_fcgi", + detected=f"no mod_proxy_fcgi.so in {env.libexec_dir}") + env.require(env.has_shared_module("brotli"), "mod_brotli not available", + dep="mod_brotli", + detected=f"no mod_brotli.so in {env.libexec_dir}") + faker = FcgiFaker(port=FCGI_PORT) faker.start()