Issues in ElementConstructorTrait.php (master) - Issues in master - spider-mane/html - Measure and Improve Code Quality continuously with Scrutinizer

Issues (4)

Security Analysis no request data

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.

Regex Injection

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

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.

Response Splitting

Response Splitting can be used to send arbitrary responses.

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.

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.

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.

Code Injection

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

Variable Injection

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

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.

Other Vulnerability

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

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.

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.

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.

Header Injection

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/Traits/ElementConstructorTrait.php (1 issue)

Severity

Unknown 1

<?php

namespace WebTheory\Html\Traits;

use WebTheory\Html\Contracts\HtmlAttributeInterface;
use WebTheory\Html\TagSage;

trait ElementConstructorTrait
{
    protected static function parseAttributes(array $attributes): string
    {
        return static::parseAttributesRealSwitch($attributes);
    }

    protected static function parseAttributesReal(array $attrArr, string &$attrStr = ''): string
    {
        foreach ($attrArr as $attr => $val) {

            // don't add empty strings or null values
            if ('' === $val && 'value' !== $attr || null === $val) {

                continue;
            }

            // treat numerical keys as boolean values
            if (is_int($attr)) {
                $attrStr .= static::renderAttribute($val, (string) $val);

                continue;
            }

            // simple attribute
            if (is_string($val) || is_numeric($val)) {
                $attrStr .= static::renderAttribute($attr, $val);

                continue;
            }

            // support interface for defining custom parsing schemes
            if ($val instanceof HtmlAttributeInterface) {
                $attrStr .= static::renderAttribute($attr, $val->parse());

                continue;
            }

            // boolean attribute
            if ($val === true) {
                $attrStr .= static::renderAttribute($attr, $attr);

                continue;
            }

            // support for passing an array of boolean values
            if ('@boolean' === $attr) {
                foreach ((array) $val as $bool) {
                    $attrStr .= static::renderAttribute($bool, $bool);
                }

                continue;
            }

            // support for converting indexed array to DOMTokenList
            if (is_array($val) && isset($val[0])) {
                $val = implode(' ', array_filter($val));
                $attrStr .= static::renderAttribute($attr, $val);

                continue;
            }

            // support for converting associative array to DOMStringMap
            if (is_array($val)) {
                foreach ($val as $set => $setval) {
                    static::parseAttributesReal(["{$attr}-{$set}" => $setval], $attrStr);
                }

                continue;
            }
        }

        return $attrStr;
    }

    protected static function parseAttributesRealSwitch(array $attrArr, string &$attrStr = ''): string
    {
        foreach ($attrArr as $attr => $val) {
            switch (true) {
                    // don't add empty strings or null values
                case ('' === $val && 'value' !== $attr || null === $val):
                    break;

                    // treat numerical keys as boolean values
                case (is_int($attr)):
                    $attrStr .= static::renderAttribute($val, (string) $val);

                    break;

                    // simple attribute
                case (is_string($val) || is_numeric($val)):
                    $attrStr .= static::renderAttribute($attr, $val);

                    break;

                    // support interface for defining custom parsing schemes
                case ($val instanceof HtmlAttributeInterface):
                    $attrStr .= static::renderAttribute($attr, $val->parse());

                    break;

                    // boolean attribute
                case ($val === true):
                    $attrStr .= static::renderAttribute($attr, $attr);

                    break;

                    // support for passing an array of boolean values
                case ('@bool' === $attr):
                    foreach ((array) $val as $bool) {
                        $attrStr .= static::renderAttribute($bool, $bool);
                    }

                    break;

                    // support for converting indexed array to DOMTokenList
                case (is_array($val) && isset($val[0])):
                    $val = implode(' ', array_filter($val));
                    $attrStr .= static::renderAttribute($attr, $val);

                    break;

                    // support for converting associative array to DOMStringMap
                case (is_array($val)):
                    foreach ($val as $set => $setval) {
                        static::parseAttributesRealSwitch(["{$attr}-{$set}" => $setval], $attrStr);
                    }

                    break;
            }
        }

        return $attrStr;
    }

    protected static function renderAttribute(string $attribute, string $value): string
    {
        $value = static::escapeAttribute($value);

        return " {$attribute}=\"{$value}\"";
    }

    protected static function escapeAttribute(string $attribute): string
    {
        return htmlspecialchars($attribute);
    }

    protected static function tag(string $tag, array $attributes = [], string $inner = ''): string
    {
        return static::open($tag, $attributes) . static::maybeClose($tag, $inner);
    }

    protected static function open(string $tag, array $attributes = []): string
    {
        $attributes = static::maybeParseAttributes($attributes);
        $slash = static::maybeAddSlash($tag);

        return "<{$tag}{$attributes}{$slash}>";
    }

    protected static function close(string $tag): string
    {
        return "</{$tag}>";
    }

    protected static function maybeClose(string $tag, string $inner = ''): string
    {
        return static::tagIsVoid($tag) ? '' : $inner . static::close($tag);
    }

    protected static function maybeParseAttributes(array $attributes): string
    {
        return empty($attributes) ? '' : static::parseAttributes($attributes);
    }

    protected static function maybeAddSlash(string $tag): string
    {
        return static::tagIsVoid($tag) ? ' /' : '';
    }

    protected static function tagIsVoid(string $tag): bool
    {
        return TagSage::isIt('self_closing', $tag);
    }

    protected static function indent(int $levels = 0): string
    {
        return str_repeat('&nbsp;', $levels);
    }

    protected static function newLine(bool $newLine = false): string
    {
        return $newLine ? "\n" : '';
    }
}


1			<?php
2
3			namespace WebTheory\Html\Traits;
4
5			use WebTheory\Html\Contracts\HtmlAttributeInterface;
6			use WebTheory\Html\TagSage;
7
8			trait ElementConstructorTrait
9			{
10			protected static function parseAttributes(array $attributes): string
11			{
12			return static::parseAttributesRealSwitch($attributes);
13			}
14
15			protected static function parseAttributesReal(array $attrArr, string &$attrStr = ''): string
16			{
17			foreach ($attrArr as $attr => $val) {
18
19			// don't add empty strings or null values
20			if ('' === $val && 'value' !== $attr \|\| null === $val) {
			0 ignored issues – show introduced 2022-05-23 20:03 UTC by Report Bug Copy Issue Report Show Similar Issues like this Consider adding parentheses for clarity. Current Interpretation: `('' === $val && 'value' ...$attr) \|\| null === $val`, Probably Intended Meaning: `'' === $val && ('value' ...$attr \|\| null === $val)` Loading history...
21			continue;
22			}
23
24			// treat numerical keys as boolean values
25			if (is_int($attr)) {
26			$attrStr .= static::renderAttribute($val, (string) $val);
27
28			continue;
29			}
30
31			// simple attribute
32			if (is_string($val) \|\| is_numeric($val)) {
33			$attrStr .= static::renderAttribute($attr, $val);
34
35			continue;
36			}
37
38			// support interface for defining custom parsing schemes
39			if ($val instanceof HtmlAttributeInterface) {
40			$attrStr .= static::renderAttribute($attr, $val->parse());
41
42			continue;
43			}
44
45			// boolean attribute
46			if ($val === true) {
47			$attrStr .= static::renderAttribute($attr, $attr);
48
49			continue;
50			}
51
52			// support for passing an array of boolean values
53			if ('@boolean' === $attr) {
54			foreach ((array) $val as $bool) {
55			$attrStr .= static::renderAttribute($bool, $bool);
56			}
57
58			continue;
59			}
60
61			// support for converting indexed array to DOMTokenList
62			if (is_array($val) && isset($val[0])) {
63			$val = implode(' ', array_filter($val));
64			$attrStr .= static::renderAttribute($attr, $val);
65
66			continue;
67			}
68
69			// support for converting associative array to DOMStringMap
70			if (is_array($val)) {
71			foreach ($val as $set => $setval) {
72			static::parseAttributesReal(["{$attr}-{$set}" => $setval], $attrStr);
73			}
74
75			continue;
76			}
77			}
78
79			return $attrStr;
80			}
81
82			protected static function parseAttributesRealSwitch(array $attrArr, string &$attrStr = ''): string
83			{
84			foreach ($attrArr as $attr => $val) {
85			switch (true) {
86			// don't add empty strings or null values
87			case ('' === $val && 'value' !== $attr \|\| null === $val):
88			break;
89
90			// treat numerical keys as boolean values
91			case (is_int($attr)):
92			$attrStr .= static::renderAttribute($val, (string) $val);
93
94			break;
95
96			// simple attribute
97			case (is_string($val) \|\| is_numeric($val)):
98			$attrStr .= static::renderAttribute($attr, $val);
99
100			break;
101
102			// support interface for defining custom parsing schemes
103			case ($val instanceof HtmlAttributeInterface):
104			$attrStr .= static::renderAttribute($attr, $val->parse());
105
106			break;
107
108			// boolean attribute
109			case ($val === true):
110			$attrStr .= static::renderAttribute($attr, $attr);
111
112			break;
113
114			// support for passing an array of boolean values
115			case ('@bool' === $attr):
116			foreach ((array) $val as $bool) {
117			$attrStr .= static::renderAttribute($bool, $bool);
118			}
119
120			break;
121
122			// support for converting indexed array to DOMTokenList
123			case (is_array($val) && isset($val[0])):
124			$val = implode(' ', array_filter($val));
125			$attrStr .= static::renderAttribute($attr, $val);
126
127			break;
128
129			// support for converting associative array to DOMStringMap
130			case (is_array($val)):
131			foreach ($val as $set => $setval) {
132			static::parseAttributesRealSwitch(["{$attr}-{$set}" => $setval], $attrStr);
133			}
134
135			break;
136			}
137			}
138
139			return $attrStr;
140			}
141
142			protected static function renderAttribute(string $attribute, string $value): string
143			{
144			$value = static::escapeAttribute($value);
145
146			return " {$attribute}=\"{$value}\"";
147			}
148
149			protected static function escapeAttribute(string $attribute): string
150			{
151			return htmlspecialchars($attribute);
152			}
153
154			protected static function tag(string $tag, array $attributes = [], string $inner = ''): string
155			{
156			return static::open($tag, $attributes) . static::maybeClose($tag, $inner);
157			}
158
159			protected static function open(string $tag, array $attributes = []): string
160			{
161			$attributes = static::maybeParseAttributes($attributes);
162			$slash = static::maybeAddSlash($tag);
163
164			return "<{$tag}{$attributes}{$slash}>";
165			}
166
167			protected static function close(string $tag): string
168			{
169			return "</{$tag}>";
170			}
171
172			protected static function maybeClose(string $tag, string $inner = ''): string
173			{
174			return static::tagIsVoid($tag) ? '' : $inner . static::close($tag);
175			}
176
177			protected static function maybeParseAttributes(array $attributes): string
178			{
179			return empty($attributes) ? '' : static::parseAttributes($attributes);
180			}
181
182			protected static function maybeAddSlash(string $tag): string
183			{
184			return static::tagIsVoid($tag) ? ' /' : '';
185			}
186
187			protected static function tagIsVoid(string $tag): bool
188			{
189			return TagSage::isIt('self_closing', $tag);
190			}
191
192			protected static function indent(int $levels = 0): string
193			{
194			return str_repeat(' ', $levels);
195			}
196
197			protected static function newLine(bool $newLine = false): string
198			{
199			return $newLine ? "\n" : '';
200			}
201			}
202

spider-mane / html

Issues (4)

Security Analysis no request data

src/Traits/ElementConstructorTrait.php (1 issue)

Severity

Introduced By

Duplication Side-by-Side

Filter issues like