← All changes | protect/fw/rule/functions/array.php +97 -23 6.62 → 6.76 View file →

		@@ -1,10 +1,10 @@
1	1	<?php
2	2	// phpcs:disable WordPress.Security.EscapeOutput.ExceptionNotEscaped
3	3	if (!defined('ABSPATH') && !defined('MCDATAPATH')) exit;
4	4
5		-if (!trait_exists('WPRProtectFWRuleArrayFunc_V662')) :
6		-trait WPRProtectFWRuleArrayFunc_V662 {
	5	+if (!trait_exists('WPRProtectFWRuleArrayFunc_V676')) :
	6	+trait WPRProtectFWRuleArrayFunc_V676 {
7	7	private function _rf_inArray() {
8	8	$args = $this->processRuleFunctionParams(
9	9	'inArray',
10	10	func_num_args(),
		@@ -15,15 +15,15 @@
15	15	$array = $args[1];
16	16	$strict = isset($args[2]) ? $args[2] : false;
17	17
18	18	if (!is_array($array)) {
19		- throw new WPRProtectRuleError_V662(
	19	+ throw new WPRProtectRuleError_V676(
20	20	$this->addExState("inArray: 2nd param is not an array")
21	21	);
22	22	}
23	23
24	24	if (!is_bool($strict)) {
25		- throw new WPRProtectRuleError_V662(
	25	+ throw new WPRProtectRuleError_V676(
26	26	$this->addExState("inArray: 3rd param is not a boolean")
27	27	);
28	28	}
29	29
		@@ -52,9 +52,9 @@
52	52	}
53	53	}
54	54	}
55	55	} else {
56		- throw new WPRProtectRuleError_V662(
	56	+ throw new WPRProtectRuleError_V676(
57	57	$this->addExState("recInArray: Expects an array")
58	58	);
59	59	}
60	60
		@@ -71,13 +71,13 @@
71	71	$key = $args[0];
72	72	$array = $args[1];
73	73
74	74	if (!is_array($array)) {
75		- throw new WPRProtectRuleError_V662(
	75	+ throw new WPRProtectRuleError_V676(
76	76	$this->addExState("arrayKeyExists: Array must be of type array")
77	77	);
78	78	} elseif (!is_string($key) && !is_int($key)) {
79		- throw new WPRProtectRuleError_V662(
	79	+ throw new WPRProtectRuleError_V676(
80	80	$this->addExState("arrayKeyExists: Key must be of type string or int")
81	81	);
82	82	}
83	83
		@@ -108,9 +108,9 @@
108	108	$array = $args[0];
109	109	$recursive = isset($args[1]) ? $args[1] : false;
110	110
111	111	if (!is_bool($recursive)) {
112		- throw new WPRProtectRuleError_V662(
	112	+ throw new WPRProtectRuleError_V676(
113	113	$this->addExState("getArrayKeys: 2nd param must be a boolean")
114	114	);
115	115	}
116	116
		@@ -138,9 +138,9 @@
138	138	$keys = $args[1];
139	139	$recursive = isset($args[2]) ? $args[2] : false;
140	140
141	141	if (!is_bool($recursive)) {
142		- throw new WPRProtectRuleError_V662(
	142	+ throw new WPRProtectRuleError_V676(
143	143	$this->addExState("hasAnyArrayKey: 3rd param must be a boolean")
144	144	);
145	145	}
146	146
		@@ -146,9 +146,9 @@
146	146
147	147	$key_lookup = array();
148	148	foreach ($keys as $key) {
149	149	if (!is_int($key) && !is_string($key)) {
150		- throw new WPRProtectRuleError_V662(
	150	+ throw new WPRProtectRuleError_V676(
151	151	$this->addExState("hasAnyArrayKey: Key must be of type string or int")
152	152	);
153	153	}
154	154
		@@ -187,9 +187,9 @@
187	187	$array = $args[1];
188	188	$recursive = isset($args[2]) ? $args[2] : false;
189	189
190	190	if (!is_bool($recursive)) {
191		- throw new WPRProtectRuleError_V662(
	191	+ throw new WPRProtectRuleError_V676(
192	192	$this->addExState("keyMatches: 3rd param must be a boolean")
193	193	);
194	194	}
195	195
		@@ -222,9 +222,9 @@
222	222	restore_error_handler();
223	223	}
224	224
225	225	if ($resp === false) {
226		- throw new WPRProtectRuleError_V662(
	226	+ throw new WPRProtectRuleError_V676(
227	227	$this->addExState("keyMatches: Invalid regular expression")
228	228	);
229	229	}
230	230	}
		@@ -231,9 +231,9 @@
231	231
232	232	private function keyMatchesPattern($pattern, $key) {
233	233	$resp = WPRHelper::safePregMatch($pattern, (string) $key);
234	234	if ($resp === false) {
235		- throw new WPRProtectRuleError_V662(
	235	+ throw new WPRProtectRuleError_V676(
236	236	$this->addExState("keyMatches: Regex match failed")
237	237	);
238	238	}
239	239
		@@ -240,9 +240,9 @@
240	240	return $resp > 0;
241	241	}
242	242
243	243	private function keyMatchesRecursive($array, $pattern, &$traversed_keys, $depth = 1) {
244		- if ($depth > WPRProtectFWRuleEngine_V662::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC) {
	244	+ if ($depth > WPRProtectFWRuleEngine_V676::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC) {
245	245	return false;
246	246	}
247	247
248	248	foreach ($array as $key => $value) {
		@@ -260,9 +260,9 @@
260	260	return false;
261	261	}
262	262
263	263	private function getArrayKeysRecursive($array, &$keys, &$traversed_keys, $depth = 1) {
264		- if ($depth > WPRProtectFWRuleEngine_V662::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC) {
	264	+ if ($depth > WPRProtectFWRuleEngine_V676::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC) {
265	265	return;
266	266	}
267	267
268	268	foreach ($array as $key => $value) {
		@@ -275,9 +275,9 @@
275	275	}
276	276	}
277	277
278	278	private function hasAnyArrayKeyRecursive($array, $key_lookup, &$traversed_keys, $depth = 1) {
279		- if ($depth > WPRProtectFWRuleEngine_V662::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC) {
	279	+ if ($depth > WPRProtectFWRuleEngine_V676::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC) {
280	280	return false;
281	281	}
282	282
283	283	foreach ($array as $key => $value) {
		@@ -295,13 +295,13 @@
295	295	return false;
296	296	}
297	297
298	298	private function enforceArrayTraversalLimit($func_name, $traversed_keys) {
299		- if ($traversed_keys > WPRProtectFWRuleEngine_V662::MAX_ARRAY_KEYS_TO_TRAVERSE) {
300		- throw new WPRProtectRuleError_V662(
	299	+ if ($traversed_keys > WPRProtectFWRuleEngine_V676::MAX_ARRAY_KEYS_TO_TRAVERSE) {
	300	+ throw new WPRProtectRuleError_V676(
301	301	$this->addExState(
302	302	"TraversalLimitError: " . $func_name . " exceeded " .
303		- WPRProtectFWRuleEngine_V662::MAX_ARRAY_KEYS_TO_TRAVERSE .
	303	+ WPRProtectFWRuleEngine_V676::MAX_ARRAY_KEYS_TO_TRAVERSE .
304	304	" array keys"
305	305	)
306	306	);
307	307	}
		@@ -319,9 +319,9 @@
319	319	$keys = $args[1];
320	320
321	321	foreach ($keys as $key) {
322	322	if (!is_int($key) && !is_string($key)) {
323		- throw new WPRProtectRuleError_V662(
	323	+ throw new WPRProtectRuleError_V676(
324	324	$this->addExState("digArray: Keys must be a valid array of string, or integer type")
325	325	);
326	326	}
327	327	}
		@@ -328,8 +328,82 @@
328	328
329	329	return WPRHelper::digArray($array, $keys);
330	330	}
331	331
	332	+ private function _rf_digArrayValues() {
	333	+ $args = $this->processRuleFunctionParams(
	334	+ 'digArrayValues',
	335	+ func_num_args(),
	336	+ func_get_args(),
	337	+ 2,
	338	+ ['mixed', 'array']
	339	+ );
	340	+ $array = $args[0];
	341	+ $keys = $args[1];
	342	+
	343	+ if (empty($keys)) {
	344	+ throw new WPRProtectRuleError_V676(
	345	+ $this->addExState("digArrayValues: Keys must not be empty")
	346	+ );
	347	+ }
	348	+
	349	+ if (count($keys) > WPRProtectFWRuleEngine_V676::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC) {
	350	+ throw new WPRProtectRuleError_V676(
	351	+ $this->addExState(
	352	+ "digArrayValues: Keys exceeded " .
	353	+ WPRProtectFWRuleEngine_V676::MAX_DEPTH_TO_ALLOWED_TYPE_FUNC .
	354	+ " levels of traversal"
	355	+ )
	356	+ );
	357	+ }
	358	+
	359	+ foreach ($keys as $key) {
	360	+ if (!is_int($key) && !is_string($key)) {
	361	+ throw new WPRProtectRuleError_V676(
	362	+ $this->addExState("digArrayValues: Keys must be a valid array of string, or integer type")
	363	+ );
	364	+ }
	365	+ }
	366	+
	367	+ $nodes = array($array);
	368	+ $traversed_keys = 0;
	369	+
	370	+ foreach ($keys as $key) {
	371	+ $next_nodes = array();
	372	+
	373	+ foreach ($nodes as $node) {
	374	+ if (!is_array($node)) {
	375	+ continue;
	376	+ }
	377	+
	378	+ if ($key === WPRProtectFWRuleEngine_V676::WILDCARD_KEY) {
	379	+ foreach ($node as $value) {
	380	+ $traversed_keys += 1;
	381	+ $this->enforceArrayTraversalLimit('digArrayValues', $traversed_keys);
	382	+ $next_nodes[] = $value;
	383	+ }
	384	+
	385	+ continue;
	386	+ }
	387	+
	388	+ $traversed_keys += 1;
	389	+ $this->enforceArrayTraversalLimit('digArrayValues', $traversed_keys);
	390	+
	391	+ if (array_key_exists($key, $node)) {
	392	+ $next_nodes[] = $node[$key];
	393	+ }
	394	+ }
	395	+
	396	+ if (empty($next_nodes)) {
	397	+ return array();
	398	+ }
	399	+
	400	+ $nodes = $next_nodes;
	401	+ }
	402	+
	403	+ return $nodes;
	404	+ }
	405	+
332	406	private function _rf_filterArray() {
333	407	$args = $this->processRuleFunctionParams(
334	408	'filterArray',
335	409	func_num_args(),
		@@ -341,9 +415,9 @@
341	415	$keys = $args[1];
342	416
343	417	foreach ($keys as $key) {
344	418	if (!is_int($key) && !is_string($key)) {
345		- throw new WPRProtectRuleError_V662(
	419	+ throw new WPRProtectRuleError_V676(
346	420	$this->addExState("filterArray: Keys must be a valid array of string, or integer type")
347	421	);
348	422	}
349	423	}
		@@ -362,9 +436,9 @@
362	436	$array = $args[0];
363	437	$key = $args[1];
364	438
365	439	if (!is_string($key) && !is_int($key)) {
366		- throw new WPRProtectRuleError_V662(
	440	+ throw new WPRProtectRuleError_V676(
367	441	$this->addExState("getArrayVal: Key must be a valid string or integer")
368	442	);
369	443	}
370	444
		@@ -443,9 +517,9 @@
443	517	$array = $args[1];
444	518
445	519	foreach ($array as $element) {
446	520	if (!is_scalar($element)) {
447		- throw new WPRProtectRuleError_V662(
	521	+ throw new WPRProtectRuleError_V676(
448	522	$this->addExState("arrayJoin: Array element must be of scalar type")
449	523	);
450	524	}
451	525	}