Commit 26e67a6934e for php

commit 26e67a6934e97e8ee42957f3d99b1df31d935470
Author: Gina Peter Banyard <girgias@php.net>
Date:   Sun Nov 22 13:43:10 2026 +0000

    zlib: refactor filter creation to do parameter validation (#22313)

diff --git a/ext/zlib/tests/zlib_filter_deflate_param_errors.phpt b/ext/zlib/tests/zlib_filter_deflate_param_errors.phpt
new file mode 100644
index 00000000000..b8bfe958036
--- /dev/null
+++ b/ext/zlib/tests/zlib_filter_deflate_param_errors.phpt
@@ -0,0 +1,107 @@
+--TEST--
+zlib.deflate filter param errors
+--EXTENSIONS--
+zlib
+--FILE--
+<?php
+$fp = fopen('php://stdout', 'w');
+
+$param = 'not an array or int';
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = -2;
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = 10;
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['memory' => 'not an int'];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['memory' => 0];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['memory' => 10];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['window' => 'not an int'];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['window' => -16];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['window' => 32];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['level' => 'not an int'];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['level' => -2];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['level' => 10];
+var_dump(stream_filter_append($fp, 'zlib.deflate', STREAM_FILTER_WRITE, $param));
+
+fclose($fp);
+
+?>
+--EXPECTF--
+Warning: stream_filter_append(): Filter parameters for zlib.deflate filter must be of type array|int, string given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Compression level must be between -1 and 9, -2 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Compression level must be between -1 and 9, 10 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Memory level must be of type int, string given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Memory level must be between 1 and 9, 0 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Memory level must be between 1 and 9, 10 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Window size must be of type int, string given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Window size must be between -15 and 31, -16 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Window size must be between -15 and 31, 32 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Compression level must be of type int, string given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Compression level must be between -1 and 9, -2 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Compression level must be between -1 and 9, 10 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.deflate" in %s on line %d
+bool(false)
diff --git a/ext/zlib/tests/zlib_filter_inflate_param_errors.phpt b/ext/zlib/tests/zlib_filter_inflate_param_errors.phpt
new file mode 100644
index 00000000000..0189f31c764
--- /dev/null
+++ b/ext/zlib/tests/zlib_filter_inflate_param_errors.phpt
@@ -0,0 +1,43 @@
+--TEST--
+zlib.inflate filter param errors
+--EXTENSIONS--
+zlib
+--FILE--
+<?php
+$fp = fopen('php://stdout', 'w');
+
+$param = 'not an array';
+var_dump(stream_filter_append($fp, 'zlib.inflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['window' => 'not an int'];
+var_dump(stream_filter_append($fp, 'zlib.inflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['window' => -16];
+var_dump(stream_filter_append($fp, 'zlib.inflate', STREAM_FILTER_WRITE, $param));
+
+$param = ['window' => 48];
+var_dump(stream_filter_append($fp, 'zlib.inflate', STREAM_FILTER_WRITE, $param));
+
+fclose($fp);
+
+?>
+--EXPECTF--
+Warning: stream_filter_append(): Filter parameters for zlib.inflate filter must be of type array, string given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.inflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Window size must be of type int, string given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.inflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Window size must be between -15 and 47, -16 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.inflate" in %s on line %d
+bool(false)
+
+Warning: stream_filter_append(): Window size must be between -15 and 47, 48 given in %s on line %d
+
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.inflate" in %s on line %d
+bool(false)
diff --git a/ext/zlib/tests/zlib_filter_unknown_errors.phpt b/ext/zlib/tests/zlib_filter_unknown_errors.phpt
new file mode 100644
index 00000000000..9f8af0391a3
--- /dev/null
+++ b/ext/zlib/tests/zlib_filter_unknown_errors.phpt
@@ -0,0 +1,16 @@
+--TEST--
+zlib.deflate filter param errors
+--EXTENSIONS--
+zlib
+--FILE--
+<?php
+$fp = fopen('php://stdout', 'w');
+
+var_dump(stream_filter_append($fp, 'zlib.unknown', STREAM_FILTER_WRITE));
+
+fclose($fp);
+
+?>
+--EXPECTF--
+Warning: stream_filter_append(): Unable to create or locate filter "zlib.unknown" in %s on line %d
+bool(false)
diff --git a/ext/zlib/zlib_filter.c b/ext/zlib/zlib_filter.c
index e71308db48d..7a10901ef3c 100644
--- a/ext/zlib/zlib_filter.c
+++ b/ext/zlib/zlib_filter.c
@@ -355,33 +355,11 @@ static const php_stream_filter_ops php_zlib_deflate_ops = {
 	"zlib.deflate"
 };

-/* }}} */
-
-/* {{{ zlib.* common factory */
-
-static php_stream_filter *php_zlib_filter_create(const char *filtername, zval *filterparams, bool persistent)
+static php_zlib_filter_data *php_zlib_filter_data_new(bool persistent)
 {
-	const php_stream_filter_ops *fops = NULL;
-	php_stream_filter_seekable_t write_seekable;
-	php_zlib_filter_data *data;
-	int status;
-
-	if (filterparams && Z_TYPE_P(filterparams) == IS_OBJECT) {
-		php_error_docref("filters.compression", E_DEPRECATED,
-			"Passing an object for filter parameters for %s is deprecated, call get_object_vars() first instead", filtername);
-		if (UNEXPECTED(EG(exception))) {
-			return NULL;
-		}
-	}
-
-	if (php_stream_filter_parse_write_seek_mode(filterparams, &write_seekable) == FAILURE) {
-		return NULL;
-	}
-
-	/* Create this filter */
-	data = pecalloc(1, sizeof(php_zlib_filter_data), persistent);
+	php_zlib_filter_data *data = pecalloc(1, sizeof(php_zlib_filter_data), persistent);
 	if (!data) {
-		php_error_docref("filters.compression", E_WARNING, "Failed allocating %zd bytes", sizeof(php_zlib_filter_data));
+		php_error_docref(NULL, E_WARNING, "Failed allocating %zd bytes", sizeof(php_zlib_filter_data));
 		return NULL;
 	}

@@ -393,14 +371,14 @@ static php_stream_filter *php_zlib_filter_create(const char *filtername, zval *f
 	data->strm.avail_out = data->outbuf_len = data->inbuf_len = 0x8000;
 	data->strm.next_in = data->inbuf = (Bytef *) pemalloc(data->inbuf_len, persistent);
 	if (!data->inbuf) {
-		php_error_docref("filters.compression", E_WARNING, "Failed allocating %zd bytes", data->inbuf_len);
+		php_error_docref(NULL, E_WARNING, "Failed allocating %zd bytes", data->inbuf_len);
 		pefree(data, persistent);
 		return NULL;
 	}
 	data->strm.avail_in = 0;
 	data->strm.next_out = data->outbuf = (Bytef *) pemalloc(data->outbuf_len, persistent);
 	if (!data->outbuf) {
-		php_error_docref("filters.compression", E_WARNING, "Failed allocating %zd bytes", data->outbuf_len);
+		php_error_docref(NULL, E_WARNING, "Failed allocating %zd bytes", data->outbuf_len);
 		pefree(data->inbuf, persistent);
 		pefree(data, persistent);
 		return NULL;
@@ -408,115 +386,212 @@ static php_stream_filter *php_zlib_filter_create(const char *filtername, zval *f

 	data->strm.data_type = Z_ASCII;
 	data->persistent = persistent;
+	return data;
+}

-	if (strcasecmp(filtername, "zlib.inflate") == 0) {
-		int windowBits = -MAX_WBITS;
+static void php_zlib_filter_data_free(php_zlib_filter_data *data, bool persistent) {
+	pefree(data->strm.next_in, persistent);
+	pefree(data->strm.next_out, persistent);
+	pefree(data, persistent);
+}

-		if (filterparams) {
-			zval *tmpzval;
+static php_stream_filter *php_zlib_deflate_filter_create(zval *filter_params, bool persistent)
+{
+	php_stream_filter_seekable_t write_seekable = PSFS_SEEKABLE_ALWAYS;
+	/* RFC 1951 Deflate */
+	int level = Z_DEFAULT_COMPRESSION;
+	int windowBits = -MAX_WBITS;
+	int memLevel = MAX_MEM_LEVEL;
+
+
+	if (filter_params) {
+		zend_long level_long;
+
+		/* filterparams can either be a scalar value to indicate compression level (shortcut method)
+		   Or can be a hash containing one or more of 'window', 'memory', and/or 'level' members. */
+		switch (Z_TYPE_P(filter_params)) {
+			case IS_OBJECT:
+				php_error_docref("filters.compression", E_DEPRECATED,
+					"Passing an object for filter parameters for zlib.deflate is deprecated, call get_object_vars() first instead");
+				if (UNEXPECTED(EG(exception))) {
+					return NULL;
+				}
+				ZEND_FALLTHROUGH;
+			case IS_ARRAY: {
+				const HashTable *ht = HASH_OF(filter_params);
+				if (php_stream_filter_parse_write_seek_mode(filter_params, &write_seekable) == FAILURE) {
+					return NULL;
+				}
+
+				const zval *memory_zv = zend_hash_str_find_ind(ht, ZEND_STRL("memory"));
+				if (memory_zv) {
+					bool failed = false;
+					/* Memory Level (1 - 9) */
+					const zend_long memory = zval_try_get_long(memory_zv, &failed);
+					if (UNEXPECTED(failed)) {
+						php_error_docref(NULL, E_WARNING, "Memory level must be of type int, %s given", zend_zval_type_name(memory_zv));
+						return NULL;
+					} else if (memory < 1 || memory > MAX_MEM_LEVEL) {
+						php_error_docref(NULL, E_WARNING, "Memory level must be between 1 and %d, " ZEND_LONG_FMT " given", MAX_MEM_LEVEL, memory);
+						return NULL;
+					} else {
+						memLevel = (int) memory;
+					}
+				}

-			if ((Z_TYPE_P(filterparams) == IS_ARRAY || Z_TYPE_P(filterparams) == IS_OBJECT) &&
-				(tmpzval = zend_hash_str_find_ind(HASH_OF(filterparams), "window", sizeof("window") - 1))) {
-				/* log-2 base of history window (9 - 15) */
-				zend_long tmp = zval_get_long(tmpzval);
-				if (tmp < -MAX_WBITS || tmp > MAX_WBITS + 32) {
-					php_error_docref("filters.compression", E_WARNING, "Invalid parameter given for window size (" ZEND_LONG_FMT ")", tmp);
+				const zval *window_zv = zend_hash_str_find_ind(ht, ZEND_STRL("window"));
+				if (window_zv) {
+					bool failed = false;
+					/* log-2 base of history window (9 - 15) */
+					const zend_long window = zval_try_get_long(window_zv, &failed);
+					if (UNEXPECTED(failed)) {
+						php_error_docref(NULL, E_WARNING, "Window size must be of type int, %s given", zend_zval_type_name(window_zv));
+						return NULL;
+					} else if (window < -MAX_WBITS || window > MAX_WBITS + 16) {
+						php_error_docref(NULL, E_WARNING, "Window size must be between %d and %d, " ZEND_LONG_FMT " given", -MAX_WBITS, MAX_WBITS + 16, window);
+						return NULL;
+					} else {
+						windowBits = (int) window;
+					}
+				}
+
+				const zval *level_zv = zend_hash_str_find_ind(ht, ZEND_STRL("level"));
+				if (level_zv) {
+					bool failed = false;
+					level_long = zval_try_get_long(level_zv, &failed);
+					if (UNEXPECTED(failed)) {
+						php_error_docref(NULL, E_WARNING, "Compression level must be of type int, %s given", zend_zval_type_name(level_zv));
+						return NULL;
+					}
+
+					/* Pseudo pass through to catch level validating code */
+					goto factory_setlevel;
+				}
+				break;
+			}
+			case IS_STRING:
+			case IS_DOUBLE:
+			case IS_LONG: {
+				bool failed = false;
+				level_long = zval_try_get_long(filter_params, &failed);
+				if (UNEXPECTED(failed)) {
+					php_error_docref(NULL, E_WARNING,
+					"Filter parameters for zlib.deflate filter must be of type array|int, %s given",
+						zend_zval_type_name(filter_params)
+					);
+					return NULL;
+				}
+factory_setlevel:
+				/* Set compression level within reason (-1 == default, 0 == none, 1-9 == least to most compression */
+				if (level_long < -1 || level_long > 9) {
+					php_error_docref(NULL, E_WARNING, "Compression level must be between -1 and 9, " ZEND_LONG_FMT " given", level_long);
+					return NULL;
 				} else {
-					windowBits = tmp;
+					level = (int) level_long;
 				}
+				break;
 			}
+
+			default:
+				php_error_docref(NULL, E_WARNING,
+				"Filter parameters for zlib.deflate filter must be of type array|int, %s given",
+					zend_zval_type_name(filter_params)
+				);
+				return NULL;
 		}
+	}

-		/* Save configuration for reset */
-		data->windowBits = windowBits;
+	php_zlib_filter_data *data = php_zlib_filter_data_new(persistent);
+	if (UNEXPECTED(data == NULL)) {
+		return NULL;
+	}
+	/* Save configuration for reset */
+	data->windowBits = windowBits;

-		/* RFC 1951 Inflate */
-		data->finished = false;
-		status = inflateInit2(&(data->strm), windowBits);
-		fops = &php_zlib_inflate_ops;
-	} else if (strcasecmp(filtername, "zlib.deflate") == 0) {
-		/* RFC 1951 Deflate */
-		int level = Z_DEFAULT_COMPRESSION;
-		int windowBits = -MAX_WBITS;
-		int memLevel = MAX_MEM_LEVEL;
-
-
-		if (filterparams) {
-			zval *tmpzval;
-			zend_long tmp;
-
-			/* filterparams can either be a scalar value to indicate compression level (shortcut method)
-               Or can be a hash containing one or more of 'window', 'memory', and/or 'level' members. */
-
-			switch (Z_TYPE_P(filterparams)) {
-				case IS_ARRAY:
-				case IS_OBJECT: {
-					HashTable *ht = HASH_OF(filterparams);
-
-					if ((tmpzval = zend_hash_str_find_ind(ht, "memory", sizeof("memory") -1))) {
-						/* Memory Level (1 - 9) */
-						tmp = zval_get_long(tmpzval);
-						if (tmp < 1 || tmp > MAX_MEM_LEVEL) {
-							php_error_docref("filters.compression", E_WARNING, "Invalid parameter given for memory level (" ZEND_LONG_FMT ")", tmp);
-						} else {
-							memLevel = tmp;
-						}
-					}
+	const int status = deflateInit2(&(data->strm), level, Z_DEFLATED, windowBits, memLevel, 0);
+	if (UNEXPECTED(status != Z_OK)) {
+		/* Unspecified (probably strm) error, let stream-filter error do its own whining */
+		php_zlib_filter_data_free(data, persistent);
+		return NULL;
+	}
+	data->finished = true;

-					if ((tmpzval = zend_hash_str_find_ind(ht, "window", sizeof("window") - 1))) {
-						/* log-2 base of history window (9 - 15) */
-						tmp = zval_get_long(tmpzval);
-						if (tmp < -MAX_WBITS || tmp > MAX_WBITS + 16) {
-							php_error_docref("filters.compression", E_WARNING, "Invalid parameter given for window size (" ZEND_LONG_FMT ")", tmp);
-						} else {
-							windowBits = tmp;
-						}
-					}
+	return php_stream_filter_alloc(&php_zlib_deflate_ops, data, persistent, PSFS_SEEKABLE_START, write_seekable);
+}

-					if ((tmpzval = zend_hash_str_find_ind(ht, "level", sizeof("level") - 1))) {
-						tmp = zval_get_long(tmpzval);

-						/* Pseudo pass through to catch level validating code */
-						goto factory_setlevel;
-					}
-					break;
-				}
-				case IS_STRING:
-				case IS_DOUBLE:
-				case IS_LONG:
-					tmp = zval_get_long(filterparams);
-factory_setlevel:
-					/* Set compression level within reason (-1 == default, 0 == none, 1-9 == least to most compression */
-					if (tmp < -1 || tmp > 9) {
-						php_error_docref("filters.compression", E_WARNING, "Invalid compression level specified. (" ZEND_LONG_FMT ")", tmp);
-					} else {
-						level = tmp;
-					}
-					break;
-				default:
-					php_error_docref("filters.compression", E_WARNING, "Invalid filter parameter, ignored");
+static php_stream_filter *php_zlib_inflate_filter_create(zval *filter_params, bool persistent)
+{
+	php_stream_filter_seekable_t write_seekable = PSFS_SEEKABLE_ALWAYS;
+	int windowBits = -MAX_WBITS;
+
+	if (filter_params) {
+		if (UNEXPECTED(Z_TYPE_P(filter_params) != IS_ARRAY && Z_TYPE_P(filter_params) != IS_OBJECT)) {
+			php_error_docref(NULL, E_WARNING,
+				"Filter parameters for zlib.inflate filter must be of type array, %s given",
+				zend_zval_type_name(filter_params)
+			);
+			return NULL;
+		}
+		if (UNEXPECTED(Z_TYPE_P(filter_params) == IS_OBJECT)) {
+			php_error_docref("filters.compression", E_DEPRECATED,
+				"Passing an object for filter parameters for zlib.inflate is deprecated, call get_object_vars() first instead");
+			if (UNEXPECTED(EG(exception))) {
+				return NULL;
 			}
 		}
+		const HashTable *filter_params_ht = HASH_OF(filter_params);
+		/* TODO: convert php_stream_filter_parse_write_seek_mode() to take HashTable */
+		if (php_stream_filter_parse_write_seek_mode(filter_params, &write_seekable) == FAILURE) {
+			return NULL;
+		}

-		/* Save configuration for reset */
-		data->windowBits = windowBits;
+		const zval *window_zv = zend_hash_str_find_ind(filter_params_ht, ZEND_STRL("window"));
+		if (window_zv) {
+			bool failed = false;
+			/* log-2 base of history window (9 - 15) */
+			const zend_long window = zval_try_get_long(window_zv, &failed);
+			if (UNEXPECTED(failed)) {
+				php_error_docref(NULL, E_WARNING, "Window size must be of type int, %s given", zend_zval_type_name(window_zv));
+				return NULL;
+			} else if (window < -MAX_WBITS || window > MAX_WBITS + 32) {
+				php_error_docref(NULL, E_WARNING, "Window size must be between %d and %d, " ZEND_LONG_FMT " given", -MAX_WBITS, MAX_WBITS + 32, window);
+				return NULL;
+			} else {
+				windowBits = (int) window;
+			}
+		}
+	}

-		status = deflateInit2(&(data->strm), level, Z_DEFLATED, windowBits, memLevel, 0);
-		data->finished = true;
-		fops = &php_zlib_deflate_ops;
-	} else {
-		status = Z_DATA_ERROR;
+	php_zlib_filter_data *data = php_zlib_filter_data_new(persistent);
+	if (UNEXPECTED(data == NULL)) {
+		return NULL;
 	}
+	/* Save configuration for reset */
+	data->windowBits = windowBits;

-	if (status != Z_OK) {
+	const int status = inflateInit2(&(data->strm), windowBits);
+	if (UNEXPECTED(status != Z_OK)) {
 		/* Unspecified (probably strm) error, let stream-filter error do its own whining */
-		pefree(data->strm.next_in, persistent);
-		pefree(data->strm.next_out, persistent);
-		pefree(data, persistent);
+		php_zlib_filter_data_free(data, persistent);
 		return NULL;
 	}
+	/* RFC 1951 Inflate */
+	data->finished = false;

-	return php_stream_filter_alloc(fops, data, persistent, PSFS_SEEKABLE_START, write_seekable);
+	return php_stream_filter_alloc(&php_zlib_inflate_ops, data, persistent, PSFS_SEEKABLE_START, write_seekable);
+}
+
+/* {{{ zlib.* common factory */
+static php_stream_filter *php_zlib_filter_create(const char *filtername, zval *filterparams, bool persistent)
+{
+	if (strcasecmp(filtername, "zlib.inflate") == 0) {
+		return php_zlib_inflate_filter_create(filterparams, persistent);
+	} else if (strcasecmp(filtername, "zlib.deflate") == 0) {
+		return php_zlib_deflate_filter_create(filterparams, persistent);
+	} else {
+		return NULL;
+	}
 }

 const php_stream_filter_factory php_zlib_filter_factory = {