diff --git a/changes-entries/66608.txt b/changes-entries/66608.txt new file mode 100644 index 00000000000..233241226c6 --- /dev/null +++ b/changes-entries/66608.txt @@ -0,0 +1,3 @@ + *) mod_proxy_fcgi: Fix SCRIPT_NAME when proxy-fcgi-pathinfo is set and the + URL path contains %-escapes; it held the whole path instead of the part + before PATH_INFO. PR 66608. [Arturo Bernal] diff --git a/modules/proxy/mod_proxy_fcgi.c b/modules/proxy/mod_proxy_fcgi.c index f9b28dc7889..e7c763879ea 100644 --- a/modules/proxy/mod_proxy_fcgi.c +++ b/modules/proxy/mod_proxy_fcgi.c @@ -29,6 +29,7 @@ typedef struct { typedef struct { char *dirwalk_uri_path; + int path_info_escaped; /* r->path_info is still %-encoded */ } fcgi_req_config_t; /* We will assume FPM, but still differentiate */ @@ -142,6 +143,7 @@ static int proxy_fcgi_canon(request_rec *r, char *url) ap_set_module_config(r->request_config, &proxy_fcgi_module, rconf); } rconf->dirwalk_uri_path = NULL; + rconf->path_info_escaped = 0; pathinfo_type = apr_table_get(r->subprocess_env, "proxy-fcgi-pathinfo"); if (pathinfo_type) { @@ -179,6 +181,9 @@ static int proxy_fcgi_canon(request_rec *r, char *url) if (!strcasecmp(pathinfo_type, "unescape")) { ap_unescape_url_keep2f(r->path_info, 0); } + else { + rconf->path_info_escaped = 1; + } ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01061) "set r->path_info to %s", r->path_info); } @@ -434,6 +439,26 @@ static apr_status_t send_environment(proxy_conn_rec *conn, request_rec *r, ap_add_common_vars(r); ap_add_cgi_vars(r); + /* ap_add_cgi_vars() finds where PATH_INFO starts in r->uri to set + * SCRIPT_NAME, which fails with a %-encoded PATH_INFO as r->uri is + * decoded: do it again with the decoded PATH_INFO. SCRIPT_NAME is the + * whole r->uri for an SSI include, which it leaves alone. + */ + if (rconf && rconf->path_info_escaped && r->path_info && *r->path_info + && strcmp(r->protocol, "INCLUDED")) { + core_dir_config *d = ap_get_core_module_config(r->per_dir_config); + char *path_info = apr_pstrdup(r->pool, r->path_info); + + if (ap_unescape_url_ex(path_info, d->decode_encoded_slashes + ? 0 : AP_UNESCAPE_URL_KEEP_SLASHES) + == OK) { + apr_table_setn(r->subprocess_env, "SCRIPT_NAME", + apr_pstrndup(r->pool, r->uri, + ap_find_path_info(r->uri, + path_info))); + } + } + /* SCRIPT_NAME/FILENAME set, restore original */ r->filename = proxy_filename; diff --git a/test/modules/proxy/env.py b/test/modules/proxy/env.py index b04ac748e61..d94a6827816 100644 --- a/test/modules/proxy/env.py +++ b/test/modules/proxy/env.py @@ -84,7 +84,7 @@ def __init__(self, env: 'HttpdTestEnv'): self.add_modules(["proxy", "proxy_http", "proxy_ajp", "proxy_balancer", "proxy_connect", "proxy_uwsgi", "lbmethod_byrequests", "remoteip"]) - self.add_optional_modules(["proxy_hcheck"]) + self.add_optional_modules(["proxy_hcheck", "proxy_fcgi", "include"]) class ProxyTestEnv(HttpdTestEnv): diff --git a/test/modules/proxy/fcgi_echo.py b/test/modules/proxy/fcgi_echo.py new file mode 100644 index 00000000000..6e88d9d8c31 --- /dev/null +++ b/test/modules/proxy/fcgi_echo.py @@ -0,0 +1,116 @@ +""" +Minimal FastCGI responder for testing mod_proxy_fcgi. + +Answers every request with a JSON body holding the CGI variables it was +sent, so that a test can check what mod_proxy_fcgi passed to the backend. +""" +import json +import socket +import struct +import threading + +FCGI_BEGIN_REQUEST = 1 +FCGI_END_REQUEST = 3 +FCGI_PARAMS = 4 +FCGI_STDIN = 5 +FCGI_STDOUT = 6 + + +def _read_exact(conn, n): + data = b"" + while len(data) < n: + chunk = conn.recv(n - len(data)) + if not chunk: + raise ConnectionError("connection closed") + data += chunk + return data + + +def _read_record(conn): + version, rtype, req_id, clen, plen, _ = \ + struct.unpack("!BBHHBB", _read_exact(conn, 8)) + content = _read_exact(conn, clen) + _read_exact(conn, plen) + return rtype, req_id, content + + +def _parse_params(data): + params = {} + pos = 0 + + def length(): + nonlocal pos + if data[pos] & 0x80: + n = struct.unpack_from("!I", data, pos)[0] & 0x7fffffff + pos += 4 + else: + n = data[pos] + pos += 1 + return n + + while pos < len(data): + nlen = length() + vlen = length() + name = data[pos:pos + nlen].decode("latin-1") + pos += nlen + params[name] = data[pos:pos + vlen].decode("latin-1") + pos += vlen + return params + + +def _record(rtype, req_id, content=b""): + return struct.pack("!BBHHBB", 1, rtype, req_id, len(content), 0, 0) + content + + +class FcgiEcho: + + def __init__(self, host, port): + self._host = host + self._port = port + self._socket = None + self._thread = None + self._done = False + + def start(self): + self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + self._socket.bind((self._host, self._port)) + self._socket.listen(5) + self._socket.settimeout(0.5) + self._thread = threading.Thread(target=self._serve, daemon=True) + self._thread.start() + + def stop(self): + self._done = True + self._thread.join(timeout=5) + self._socket.close() + + def _serve(self): + while not self._done: + try: + conn, _ = self._socket.accept() + except socket.timeout: + continue + except OSError: + break + with conn: + conn.settimeout(5) + try: + self._handle(conn) + except (ConnectionError, socket.timeout, struct.error): + pass + + def _handle(self, conn): + req_id = 1 + params = b"" + while True: + rtype, req_id, content = _read_record(conn) + if rtype == FCGI_PARAMS: + params += content + elif rtype == FCGI_STDIN and not content: + break + body = json.dumps(_parse_params(params)).encode() + head = b"Content-Type: application/json\r\n\r\n" + conn.sendall(_record(FCGI_STDOUT, req_id, head + body) + + _record(FCGI_STDOUT, req_id) + + _record(FCGI_END_REQUEST, req_id, b"\0" * 8)) diff --git a/test/modules/proxy/test_12_fcgi_script_name.py b/test/modules/proxy/test_12_fcgi_script_name.py new file mode 100644 index 00000000000..be5cf15d1de --- /dev/null +++ b/test/modules/proxy/test_12_fcgi_script_name.py @@ -0,0 +1,80 @@ +import json +import os + +import pytest + +from pyhttpd.conf import HttpdConf +from .fcgi_echo import FcgiEcho + + +class TestProxyFcgiScriptName: + """SCRIPT_NAME sent to a FastCGI backend with proxy-fcgi-pathinfo set. + It must not include the PATH_INFO part (RFC 3875 4.1.13), also when the + URL path holds %-escapes (PR 66608).""" + + @pytest.fixture(autouse=True, scope='class') + def _class_scope(self, 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("include"), + "mod_include not available", dep="mod_include", + detected=f"no mod_include.so in {env.libexec_dir}") + # An SSI page including the FastCGI paths as subrequests, which run + # with SERVER_PROTOCOL "INCLUDED". + with open(os.path.join(env.server_dir, "htdocs", "fcgi_inc.shtml"), + "w") as fd: + fd.write('@@@@\n' + '@@@@\n') + backend = FcgiEcho("127.0.0.1", env.http_port2) + backend.start() + conf = HttpdConf(env) + conf.start_vhost(domains=[f"test1.{env.http_tld}"], port=env.http_port) + conf.add([ + "SetEnvIf Request_URI ^/app/ proxy-fcgi-pathinfo=1", + "SetEnvIf Request_URI ^/unesc/ proxy-fcgi-pathinfo=unescape", + "ProxyFCGIBackendType GENERIC", + f"ProxyPass /app/ fcgi://127.0.0.1:{env.http_port2}/", + f"ProxyPass /unesc/ fcgi://127.0.0.1:{env.http_port2}/", + # SetEnvIf does not run for subrequests, mod_rewrite does. + "", + " RewriteEngine on", + " RewriteRule ^ - [E=proxy-fcgi-pathinfo:1]", + "", + f"ProxyPass /inc/ fcgi://127.0.0.1:{env.http_port2}/", + "", + " Options +Includes", + " SetOutputFilter INCLUDES", + "", + ]) + conf.end_vhost() + conf.install() + assert env.apache_restart() == 0 + yield + backend.stop() + + @pytest.mark.parametrize("path, script_name, path_info", [ + ("/app/a/b", "/app", "/a/b"), + ("/app/a/x%20y", "/app", "/a/x%20y"), + ("/app/%C3%A9t%C3%A9/z", "/app", "/%C3%A9t%C3%A9/z"), + ("/unesc/a/x%20y", "/unesc", "/a/x y"), + ]) + def test_proxy_012_01(self, env, path, script_name, path_info): + r = env.curl_get(env.mkurl("http", "test1", path)) + assert r.response["status"] == 200 + params = json.loads(r.response["body"]) + assert params["SCRIPT_NAME"] == script_name + assert params["PATH_INFO"] == path_info + + def test_proxy_012_02(self, env): + """An SSI include keeps the SCRIPT_NAME core gives "INCLUDED" + subrequests, the whole URI, escaped or not.""" + r = env.curl_get(env.mkurl("http", "test1", "/fcgi_inc.shtml")) + assert r.response["status"] == 200 + included = [json.loads(part) for part in + r.response["body"].decode().split("@@")[1::2]] + assert [(p["SERVER_PROTOCOL"], p["SCRIPT_NAME"], p["PATH_INFO"]) + for p in included] == [ + ("INCLUDED", "/inc/a/b", "/a/b"), + ("INCLUDED", "/inc/a b/c", "/a%20b/c"), + ]