Issues in Field.php (master) - Issues in master - harryosmar/plugin-validation - Measure and Improve Code Quality continuously with Scrutinizer

Issues (20)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

src/MultiValues/Field.php (2 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
/**
 * Created by PhpStorm.
 * User: harry
 * Date: 2/26/18
 * Time: 4:53 PM
 */

namespace PluginSimpleValidate\MultiValues;

use PluginSimpleValidate\Contracts\MultiValuesField;
use PluginSimpleValidate\BaseAbstract\RuleMapping as AbstractRuleMapping;
use PluginSimpleValidate\Contracts\RuleWithValue;
use PluginSimpleValidate\Libraries\Language;

class Field extends \PluginSimpleValidate\BaseAbstract\Field implements MultiValuesField
{
    /**
     * @param Language $language
     * @return bool
     */
    public function isValid(Language $language) : bool

    {
        // empty the `errors` array

        $this->emptyErrors();

        /** @var RuleWithValue $rule */
        foreach ($this->rules as $ruleName => $rule) {
            if (!$rule->isValid($language, $rule->getValue())) {
                $this->status = false;
                $this->errors[] = $rule->getError();
            }
        }

        if (empty($this->errors)) {
            $this->status = true;
        }

        return $this->status;
    }

    /**
     * @param string $rulesMethod
     * @param mixed $value
     * @param array $args
     * @return $this
     */
    public function addRules(string $rulesMethod, $value, array $args = [])
    {
        $this->rules[uniqid(rand(), true) . $rulesMethod] = \PluginSimpleValidate\Libraries\MultiValues\RuleMapping::getInstance()->getRule($rulesMethod, $value, $args);
        return $this;
    }

    /**
     * Field constructor.
     * @param string $name
     */
    public function __construct(string $name)
    {
        parent::__construct($name, null);
    }

    /**
     * @param $value
     * @param string $message
     * @return $this
     */
    public function isTrue($value, string $message = '')
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_IS_TRUE, $value, [static::VAR_MESSAGE => $message]);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function required($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_REQUIRED, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function notEmpty($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_IS_NOT_EMPTY, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function validEmail($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_EMAIL, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int|string $match
     * @return $this
     */
    public function equal($value, $match)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_EQUAL, $value, [static::VAR_MATCH => $match]);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function isNumber($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_NUMBER, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function isAlpha($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_ALPHA, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function isAlphaOrNumeric($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_ALPHA_OR_NUMERIC, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function isDecimal($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_DECIMAL, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function isInteger($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_INTEGER, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function isNatural($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NUMBER, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @return $this
     */
    public function isNaturalNoZero($value)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NO_ZERO_NUMBER, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function lessThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LESS_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function greaterThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_GREATER_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function lessOrEqualThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LESS_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function greaterOrEqualThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_GREATER_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $lower
     * @param float|int $upper
     * @return $this
     */
    public function between($value, $lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $lower
     * @param float|int $upper
     * @return $this
     */
    public function betweenOrEqual($value, $lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN_OR_EQUAL_THAN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function length($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH, $value);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function lengthLessThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function lengthGreaterThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function lengthLessOrEqualThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $limit
     * @return $this
     */
    public function lengthGreaterOrEqualThan($value, $limit)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $lower
     * @param float|int $upper
     * @return $this
     */
    public function lengthBetween($value, $lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param float|int $lower
     * @param float|int $upper
     * @return $this
     */
    public function lengthBetweenOrEqual($value, $lower, $upper)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN_OR_EQUAL_THAN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
        return $this;
    }

    /**
     * @param mixed $value
     * @param string $region
     * @return $this
     */
    public function isValidPhone($value, string $region)
    {
        $this->addRules(AbstractRuleMapping::VALIDATE_PHONE_NUMBER, $value, [static::VAR_REGION => $region]);
        return $this;
    }
}

1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: harry
5			* Date: 2/26/18
6			* Time: 4:53 PM
7			*/
8
9			namespace PluginSimpleValidate\MultiValues;
10
11			use PluginSimpleValidate\Contracts\MultiValuesField;
12			use PluginSimpleValidate\BaseAbstract\RuleMapping as AbstractRuleMapping;
13			use PluginSimpleValidate\Contracts\RuleWithValue;
14			use PluginSimpleValidate\Libraries\Language;
15
16			class Field extends \PluginSimpleValidate\BaseAbstract\Field implements MultiValuesField
17			{
18			/**
19			* @param Language $language
20			* @return bool
21			*/
22	4	View Code Duplication	public function isValid(Language $language) : bool
			0 ignored issues – show Duplication introduced 2018-02-26 11:59 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
23			{
24			// empty the `errors` array
			0 ignored issues – show Unused Code Comprehensibility introduced 2018-02-21 10:13 UTC by Report Bug Copy Issue Report Show Similar Issues like this `40%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
25	4		$this->emptyErrors();
26
27			/** @var RuleWithValue $rule */
28	4		foreach ($this->rules as $ruleName => $rule) {
29	4		if (!$rule->isValid($language, $rule->getValue())) {
30	4		$this->status = false;
31	4		$this->errors[] = $rule->getError();
32			}
33			}
34
35	4		if (empty($this->errors)) {
36			$this->status = true;
37			}
38
39	4		return $this->status;
40			}
41
42			/**
43			* @param string $rulesMethod
44			* @param mixed $value
45			* @param array $args
46			* @return $this
47			*/
48	4		public function addRules(string $rulesMethod, $value, array $args = [])
49			{
50	4		$this->rules[uniqid(rand(), true) . $rulesMethod] = \PluginSimpleValidate\Libraries\MultiValues\RuleMapping::getInstance()->getRule($rulesMethod, $value, $args);
51	4		return $this;
52			}
53
54			/**
55			* Field constructor.
56			* @param string $name
57			*/
58	5		public function __construct(string $name)
59			{
60	5		parent::__construct($name, null);
61	5		}
62
63			/**
64			* @param $value
65			* @param string $message
66			* @return $this
67			*/
68	3		public function isTrue($value, string $message = '')
69			{
70	3		$this->addRules(AbstractRuleMapping::VALIDATE_IS_TRUE, $value, [static::VAR_MESSAGE => $message]);
71	3		return $this;
72			}
73
74			/**
75			* @param mixed $value
76			* @return $this
77			*/
78	1		public function required($value)
79			{
80	1		$this->addRules(AbstractRuleMapping::VALIDATE_REQUIRED, $value);
81	1		return $this;
82			}
83
84			/**
85			* @param mixed $value
86			* @return $this
87			*/
88			public function notEmpty($value)
89			{
90			$this->addRules(AbstractRuleMapping::VALIDATE_IS_NOT_EMPTY, $value);
91			return $this;
92			}
93
94			/**
95			* @param mixed $value
96			* @return $this
97			*/
98	1		public function validEmail($value)
99			{
100	1		$this->addRules(AbstractRuleMapping::VALIDATE_EMAIL, $value);
101	1		return $this;
102			}
103
104			/**
105			* @param mixed $value
106			* @param float\|int\|string $match
107			* @return $this
108			*/
109			public function equal($value, $match)
110			{
111			$this->addRules(AbstractRuleMapping::VALIDATE_EQUAL, $value, [static::VAR_MATCH => $match]);
112			return $this;
113			}
114
115			/**
116			* @param mixed $value
117			* @return $this
118			*/
119			public function isNumber($value)
120			{
121			$this->addRules(AbstractRuleMapping::VALIDATE_NUMBER, $value);
122			return $this;
123			}
124
125			/**
126			* @param mixed $value
127			* @return $this
128			*/
129			public function isAlpha($value)
130			{
131			$this->addRules(AbstractRuleMapping::VALIDATE_ALPHA, $value);
132			return $this;
133			}
134
135			/**
136			* @param mixed $value
137			* @return $this
138			*/
139			public function isAlphaOrNumeric($value)
140			{
141			$this->addRules(AbstractRuleMapping::VALIDATE_ALPHA_OR_NUMERIC, $value);
142			return $this;
143			}
144
145			/**
146			* @param mixed $value
147			* @return $this
148			*/
149			public function isDecimal($value)
150			{
151			$this->addRules(AbstractRuleMapping::VALIDATE_DECIMAL, $value);
152			return $this;
153			}
154
155			/**
156			* @param mixed $value
157			* @return $this
158			*/
159			public function isInteger($value)
160			{
161			$this->addRules(AbstractRuleMapping::VALIDATE_INTEGER, $value);
162			return $this;
163			}
164
165			/**
166			* @param mixed $value
167			* @return $this
168			*/
169			public function isNatural($value)
170			{
171			$this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NUMBER, $value);
172			return $this;
173			}
174
175			/**
176			* @param mixed $value
177			* @return $this
178			*/
179			public function isNaturalNoZero($value)
180			{
181			$this->addRules(AbstractRuleMapping::VALIDATE_NATURAL_NO_ZERO_NUMBER, $value);
182			return $this;
183			}
184
185			/**
186			* @param mixed $value
187			* @param float\|int $limit
188			* @return $this
189			*/
190			public function lessThan($value, $limit)
191			{
192			$this->addRules(AbstractRuleMapping::VALIDATE_LESS_THAN, $value, [static::VAR_LIMIT => $limit]);
193			return $this;
194			}
195
196			/**
197			* @param mixed $value
198			* @param float\|int $limit
199			* @return $this
200			*/
201			public function greaterThan($value, $limit)
202			{
203			$this->addRules(AbstractRuleMapping::VALIDATE_GREATER_THAN, $value, [static::VAR_LIMIT => $limit]);
204			return $this;
205			}
206
207			/**
208			* @param mixed $value
209			* @param float\|int $limit
210			* @return $this
211			*/
212			public function lessOrEqualThan($value, $limit)
213			{
214			$this->addRules(AbstractRuleMapping::VALIDATE_LESS_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
215			return $this;
216			}
217
218			/**
219			* @param mixed $value
220			* @param float\|int $limit
221			* @return $this
222			*/
223			public function greaterOrEqualThan($value, $limit)
224			{
225			$this->addRules(AbstractRuleMapping::VALIDATE_GREATER_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
226			return $this;
227			}
228
229			/**
230			* @param mixed $value
231			* @param float\|int $lower
232			* @param float\|int $upper
233			* @return $this
234			*/
235			public function between($value, $lower, $upper)
236			{
237			$this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
238			return $this;
239			}
240
241			/**
242			* @param mixed $value
243			* @param float\|int $lower
244			* @param float\|int $upper
245			* @return $this
246			*/
247			public function betweenOrEqual($value, $lower, $upper)
248			{
249			$this->addRules(AbstractRuleMapping::VALIDATE_BETWEEN_OR_EQUAL_THAN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
250			return $this;
251			}
252
253			/**
254			* @param mixed $value
255			* @param float\|int $limit
256			* @return $this
257			*/
258			public function length($value, $limit)
259			{
260			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH, $value);
261			return $this;
262			}
263
264			/**
265			* @param mixed $value
266			* @param float\|int $limit
267			* @return $this
268			*/
269			public function lengthLessThan($value, $limit)
270			{
271			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_THAN, $value, [static::VAR_LIMIT => $limit]);
272			return $this;
273			}
274
275			/**
276			* @param mixed $value
277			* @param float\|int $limit
278			* @return $this
279			*/
280			public function lengthGreaterThan($value, $limit)
281			{
282			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_THAN, $value, [static::VAR_LIMIT => $limit]);
283			return $this;
284			}
285
286			/**
287			* @param mixed $value
288			* @param float\|int $limit
289			* @return $this
290			*/
291			public function lengthLessOrEqualThan($value, $limit)
292			{
293			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_LESS_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
294			return $this;
295			}
296
297			/**
298			* @param mixed $value
299			* @param float\|int $limit
300			* @return $this
301			*/
302			public function lengthGreaterOrEqualThan($value, $limit)
303			{
304			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_GREATER_OR_EQUAL_THAN, $value, [static::VAR_LIMIT => $limit]);
305			return $this;
306			}
307
308			/**
309			* @param mixed $value
310			* @param float\|int $lower
311			* @param float\|int $upper
312			* @return $this
313			*/
314			public function lengthBetween($value, $lower, $upper)
315			{
316			$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
317			return $this;
318			}
319
320			/**
321			* @param mixed $value
322			* @param float\|int $lower
323			* @param float\|int $upper
324			* @return $this
325			*/
326	1		public function lengthBetweenOrEqual($value, $lower, $upper)
327			{
328	1		$this->addRules(AbstractRuleMapping::VALIDATE_LENGTH_BETWEEN_OR_EQUAL_THAN, $value, [static::VAR_LOWER_LIMIT => $lower, static::VAR_UPPER_LIMIT => $upper]);
329	1		return $this;
330			}
331
332			/**
333			* @param mixed $value
334			* @param string $region
335			* @return $this
336			*/
337			public function isValidPhone($value, string $region)
338			{
339			$this->addRules(AbstractRuleMapping::VALIDATE_PHONE_NUMBER, $value, [static::VAR_REGION => $region]);
340			return $this;
341			}
342			}

harryosmar / plugin-validation

Issues (20)

Security Analysis not enabled

src/MultiValues/Field.php (2 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like