diff --git a/changes-entries/70319.txt b/changes-entries/70319.txt new file mode 100644 index 00000000000..72cf9521a2e --- /dev/null +++ b/changes-entries/70319.txt @@ -0,0 +1,4 @@ + *) mod_ldap: Fix a memory leak: util_ald_create_caches() leaked the + three per-URL caches it had just created whenever the shared URL + cache was full and the purge could not free an entry. PR 70319 + [Arturo Bernal] diff --git a/modules/ldap/util_ldap_cache_mgr.c b/modules/ldap/util_ldap_cache_mgr.c index 0300a8b1852..bd49eb7042a 100644 --- a/modules/ldap/util_ldap_cache_mgr.c +++ b/modules/ldap/util_ldap_cache_mgr.c @@ -313,6 +313,8 @@ util_url_node_t *util_ald_create_caches(util_ldap_state_t *st, const char *url) /* check that all the caches initialised successfully */ if (search_cache && compare_cache && dn_compare_cache) { + util_url_node_t *node; + /* The contents of this structure will be duplicated in shared memory during the insert. So use stack memory rather than pool memory to avoid a memory leak. */ @@ -322,7 +324,16 @@ util_url_node_t *util_ald_create_caches(util_ldap_state_t *st, const char *url) curl.compare_cache = compare_cache; curl.dn_compare_cache = dn_compare_cache; - return util_ald_cache_insert(st->util_ldap_cache, &curl); + node = util_ald_cache_insert(st->util_ldap_cache, &curl); + if (node == NULL) { + /* The URL cache was full and the purge freed nothing; the + * insert never happened, so these three caches are not + * referenced from anywhere and must be destroyed here. */ + util_ald_destroy_cache(search_cache); + util_ald_destroy_cache(compare_cache); + util_ald_destroy_cache(dn_compare_cache); + } + return node; } else { /* util_ald_destroy_cache is a noop for a NULL argument. */ diff --git a/test/modules/ldap/__init__.py b/test/modules/ldap/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/test/modules/ldap/conftest.py b/test/modules/ldap/conftest.py new file mode 100644 index 00000000000..25cac8f3170 --- /dev/null +++ b/test/modules/ldap/conftest.py @@ -0,0 +1,35 @@ +import logging +import os + +import pytest +import sys + +from .env import LdapTestEnv + +sys.path.append(os.path.join(os.path.dirname(__file__), '../..')) + + +def pytest_report_header(config, start_path): + env = LdapTestEnv() + return f"ldap [apache: {env.get_httpd_version()}, mpm: {env.mpm_module}, {env.prefix}]" + + +@pytest.fixture(scope="package") +def env(pytestconfig) -> LdapTestEnv: + level = logging.INFO + console = logging.StreamHandler() + console.setLevel(level) + console.setFormatter(logging.Formatter('%(levelname)s: %(message)s')) + logging.getLogger('').addHandler(console) + logging.getLogger('').setLevel(level=level) + env = LdapTestEnv(pytestconfig=pytestconfig) + env.setup_httpd() + env.apache_access_log_clear() + env.httpd_error_log.clear_log() + return env + + +@pytest.fixture(autouse=True, scope="package") +def _stop_package_scope(env): + yield + assert env.apache_stop() == 0 diff --git a/test/modules/ldap/env.py b/test/modules/ldap/env.py new file mode 100644 index 00000000000..ce18f35e535 --- /dev/null +++ b/test/modules/ldap/env.py @@ -0,0 +1,27 @@ +import inspect +import logging +import os + +from pyhttpd.env import HttpdTestEnv, HttpdTestSetup + +log = logging.getLogger(__name__) + + +class LdapTestSetup(HttpdTestSetup): + + def __init__(self, env: 'HttpdTestEnv'): + super().__init__(env=env) + self.add_source_dir(os.path.dirname(inspect.getfile(LdapTestSetup))) + # mod_ldap/mod_authnz_ldap need libldap, so they may not have + # been built; the tests skip when either is absent. + self.add_optional_modules(["ldap", "authnz_ldap"]) + + +class LdapTestEnv(HttpdTestEnv): + + def __init__(self, pytestconfig=None): + super().__init__(pytestconfig=pytestconfig) + self.add_httpd_log_modules(["ldap", "authnz_ldap"]) + + def setup_httpd(self, setup: HttpdTestSetup = None): + super().setup_httpd(setup=LdapTestSetup(env=self)) diff --git a/test/modules/ldap/test_001_cache_leak.py b/test/modules/ldap/test_001_cache_leak.py new file mode 100644 index 00000000000..1a898033c8a --- /dev/null +++ b/test/modules/ldap/test_001_cache_leak.py @@ -0,0 +1,146 @@ +import http.client +import os +import sys + +import pytest + +from pyhttpd.conf import HttpdConf + +# What mod_ldap logs when the per-URL cache is full and the purge +# frees nothing; expected here on every request, since LDAPCacheEntries 1 +# makes the purge (which only removes entries older than LDAPCacheTTL) +# never effective within the life of this test. +CACHE_FULL_LOGNO = ["AH01323"] + +REQUESTS_PER_PATH = 2000 + +# A real leak here is a few KB per request (three small caches); this +# is comfortably above allocator noise for an otherwise-idle process +# and comfortably below the multi-MB growth a real leak produces over +# REQUESTS_PER_PATH iterations. +LIMIT_KB = 4096 + + +def _children_rss_kb(ppid): + """Sum VmRSS (kB) across all direct children of the httpd main + process. The main process itself does not serve requests.""" + total = 0 + for entry in os.listdir("/proc"): + if not entry.isdigit(): + continue + try: + with open(f"/proc/{entry}/stat") as fd: + fields = fd.read().split() + if int(fields[3]) != ppid: + continue + with open(f"/proc/{entry}/status") as fd: + for line in fd: + if line.startswith("VmRSS:"): + total += int(line.split()[1]) + break + except (FileNotFoundError, ProcessLookupError, IndexError, ValueError): + continue + return total + + +def _built_with_asan(env): + """Whether httpd is AddressSanitizer instrumented: its quarantine and + shadow memory grow RSS by far more than any leak this test looks for.""" + with open(os.path.join(env.bin_dir, "httpd"), "rb") as fd: + return b"__asan_init" in fd.read() + + +# Class scoped, to outlast the error log check made after each test. +@pytest.fixture(scope='class') +def _expect_cache_full(env): + env.httpd_error_log.add_ignored_lognos(CACHE_FULL_LOGNO) + yield + env.httpd_error_log.remove_ignored_lognos(CACHE_FULL_LOGNO) + + +# With LDAPCacheEntries 1, alternating requests for two AuthLDAPURLs +# always find the shared URL cache full: whichever URL was cached by +# the previous request is still there (LDAPCacheTTL has not elapsed), +# so util_ald_cache_insert() returns NULL for the other one every +# time. util_ald_create_caches() must free the three per-URL caches +# it just created in that case, not leak them. BZ 70319. +# The growth is read from /proc, hence Linux only. +@pytest.mark.skipif(not sys.platform.startswith("linux"), + reason="reads process memory from /proc") +@pytest.mark.usefixtures("_expect_cache_full") +class TestLdapCacheLeak: + + @pytest.fixture(autouse=True, scope='class') + def _class_scope(self, env): + if _built_with_asan(env): + pytest.skip("RSS growth is meaningless under AddressSanitizer") + env.require(env.has_shared_module("ldap"), "mod_ldap not built", + dep="mod_ldap") + env.require(env.has_shared_module("authnz_ldap"), "mod_authnz_ldap not built", + dep="mod_authnz_ldap") + # Pin every request to a single worker process, so the RSS growth + # measured below reflects that one process's heap and is not + # confused by the MPM scaling up its number of children under load. + mpm_pin = "StartServers 1\nServerLimit 1\nMaxRequestWorkers 16\n" + if env.mpm_module in ("mpm_worker", "mpm_event"): + mpm_pin += "ThreadsPerChild 16\nMinSpareThreads 1\nMaxSpareThreads 16\n" + conf = HttpdConf(env, extras={ + 'base': f""" + LDAPSharedCacheSize 0 + LDAPCacheEntries 1 + {mpm_pin} + """, + f"test1.{env.http_tld}": """ + + AuthType Basic + AuthName a + AuthBasicProvider ldap + AuthLDAPURL "ldap://127.0.0.1:1/dc=a?uid" + Require valid-user + + + AuthType Basic + AuthName b + AuthBasicProvider ldap + AuthLDAPURL "ldap://127.0.0.1:1/dc=b?uid" + Require valid-user + + """, + }) + conf.add_vhost_test1() + conf.install() + assert env.apache_restart() == 0 + + def test_ldap_001_01_cache_insert_failure_leak(self, env): + host = f"test1.{env.http_tld}" + conn = http.client.HTTPConnection(env.http_addr, env.http_port, timeout=10) + try: + # Warm-up: settle the connection and the allocator before + # measuring, and confirm the cache-miss path is really hit. + for path in ("a", "b", "a", "b"): + conn.request("GET", f"/ldapcacheleak/{path}", headers={ + "Host": host, "Authorization": "Basic dXNlcjpwdw==", + }) + r = conn.getresponse() + r.read() + assert r.status == 500, r.status # no real LDAP server + + main_pid = env.read_pid_file() + before = _children_rss_kb(main_pid) + + for _ in range(REQUESTS_PER_PATH): + for path in ("a", "b"): + conn.request("GET", f"/ldapcacheleak/{path}", headers={ + "Host": host, "Authorization": "Basic dXNlcjpwdw==", + }) + r = conn.getresponse() + r.read() + assert r.status == 500, r.status + + after = _children_rss_kb(main_pid) + finally: + conn.close() + + growth = after - before + assert growth < LIMIT_KB, \ + f"{2 * REQUESTS_PER_PATH} requests grew httpd by {growth}kB"