Issues in AbstractStructureParser.php (master) - Issues in master - appserver-io/doppelgaenger - Measure and Improve Code Quality continuously with Scrutinizer

Issues (245)

Security Analysis no request data

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/Parser/AbstractStructureParser.php (29 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

/**
 * \AppserverIo\Doppelgaenger\Parser\AbstractStructureParser
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Bernhard Wick <[email protected]>
 * @copyright 2015 TechDivision GmbH - <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */

namespace AppserverIo\Doppelgaenger\Parser;

use AppserverIo\Doppelgaenger\Entities\Lists\StructureDefinitionList;
use AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface;
use AppserverIo\Doppelgaenger\Interfaces\StructureParserInterface;
use AppserverIo\Doppelgaenger\Entities\Definitions\FileDefinition;

/**
 * The abstract class AbstractStructureParser which provides a basic implementation other structure parsers
 * can inherit from
 *
 * @author    Bernhard Wick <[email protected]>
 * @copyright 2015 TechDivision GmbH - <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/appserver-io/doppelgaenger
 * @link      http://www.appserver.io/
 */
abstract class AbstractStructureParser extends AbstractParser implements StructureParserInterface
{

    /**
     * Will return the constants within the main token array
     *
     * @return array
     */
    public function getConstants()
    {
        // Check the tokens
        $constants = array();
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // If we got the class name
            if ($this->tokens[$i][0] === T_CONST) {
                for ($j = $i + 1; $j < $this->tokenCount; $j++) {
                    if ($this->tokens[$j] === ';') {
                        break;


                    } elseif ($this->tokens[$j][0] === T_STRING) {
                        $constants[$this->tokens[$j][1]] = '';

                        for ($k = $j + 1; $k < count($this->tokens); $k++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                            if ($this->tokens[$k] === ';') {
                                break;


                            } elseif (is_array($this->tokens[$k]) && $this->tokens[$k][0] !== '=') {
                                $constants[$this->tokens[$j][1]] .= $this->tokens[$k][1];
                            }
                        }

                        // Now trim what we got
                        $constants[$this->tokens[$j][1]] = trim($constants[$this->tokens[$j][1]]);
                    }
                }
            }
        }

        // Return what we did or did not found
        return $constants;
    }

    /**
     * Will return the definition of a specified structure
     *
     * @param null|string $name         The name of the class we are searching for
     * @param boolean     $getRecursive Do we have to get the ancestral conditions as well?
     *
     * @return boolean|\AppserverIo\Doppelgaenger\Interfaces\StructureDefinitionInterface
     */
    public function getDefinition($name = null, $getRecursive = true)
    {
        // Maybe we already got this structure?
        if ($this->structureDefinitionHierarchy->entryExists($name)) {
            return $this->structureDefinitionHierarchy->getEntry($name);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        // First of all we need to get the structure tokens
        $tokens = $this->getStructureTokens($this->getToken());

        // Did we get something valuable?
        if ($tokens === false) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}


        } elseif ($name === null && count($tokens) > 1) {
            // If we did not get a structure name and we got more than one class we can fail right here
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}


        } elseif (count($tokens) === 1) {
            // We got what we came for
            return $this->getDefinitionFromTokens($tokens[0], $getRecursive);



        } elseif (is_string($name) && count($tokens) > 1) {
            // We are still here, but got a structure name to look for

            foreach ($tokens as $key => $token) {
                // Now iterate over the array and search for the class we want
                for ($i = 0; $i < count($token); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if (is_array($token[$i]) && $token[$i] === $this->getToken() && $token[$i + 2] === $name) {
                        return $this->getDefinitionFromTokens($tokens[$key], $getRecursive);

                    }
                }
            }
        }

        // Still here? Must be an error.
        return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * Will return a list of found structures or false on error
     *
     * @param string         $file           Path of the file we are searching in
     * @param FileDefinition $fileDefinition Definition of the file the class is in
     * @param boolean        $getRecursive   Do we have to get the ancestral conditions as well?
     *
     * @return boolean|StructureDefinitionList
     */
    public function getDefinitionListFromFile($file, FileDefinition $fileDefinition, $getRecursive = true)
    {
        // Get all the token arrays for the different classes
        $tokens = $this->getStructureTokens($file, $this->getToken());


        // Did we get the right thing?
        if (!is_array($tokens)) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        $structureDefinitionList = new StructureDefinitionList();
        foreach ($tokens as $token) {
            try {
                $structureDefinitionList->add($this->getDefinitionFromTokens($token, $fileDefinition, $getRecursive));



            } catch (\UnexpectedValueException $e) {
                // Just try the next one
                continue;
            }
        }

        return $structureDefinitionList;
    }

    /**
     * Get the name of the structure
     *
     * @param array $tokens The token array
     *
     * @return string
     */
    protected function getName($tokens)
    {
        // Check the tokens
        $name = '';
        $targetToken = $this->getToken();
        for ($i = 0; $i < count($tokens); $i++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            // If we got the structure name
            if ($tokens[$i][0] === $targetToken && $tokens[$i - 1][0] !== T_PAAMAYIM_NEKUDOTAYIM) {
                for ($j = $i + 1; $j < count($tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($tokens[$j] === '{') {
                        $name = $tokens[$i + 2][1];
                    }
                }
            }
        }

        // Return what we did or did not found
        return $name;
    }

    /**
     * Will return the structure's namespace if found
     *
     * @return string
     */
    public function getNamespace()
    {
        // Check the tokens
        $namespace = '';
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // If we got the namespace
            if ($this->tokens[$i][0] === T_NAMESPACE) {
                for ($j = $i + 1; $j < count($this->tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($this->tokens[$j][0] === T_STRING) {
                        $namespace .= '\\' . $this->tokens[$j][1];


                    } elseif ($this->tokens[$j] === '{' ||
                        $this->tokens[$j] === ';' ||
                        $this->tokens[$j][0] === T_CURLY_OPEN
                    ) {
                        break;
                    }
                }
            }
        }

        // Return what we did or did not found
        return substr($namespace, 1);
    }

    /**
     * Will check the main token array for the occurrence of a certain on (class, interface or trait)
     *
     * @return string|boolean
     */
    protected function getStructureToken()
    {
        for ($i = 0; $i < $this->tokenCount; $i++) {
            switch ($this->tokens[$i][0]) {
                case T_CLASS:
                    return 'class';
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                case T_INTERFACE:
                    return 'interface';
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                case T_TRAIT:
                    return 'trait';
                    break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

                default:
                    continue;
                    break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            }
        }

        // We are still here? That should not be.
        return false;
    }

    /**
     * Will check if a certain token describes a structure
     *
     * @param mixed $token The token to test
     *
     * @return boolean
     */
    protected function isStructureToken($token)
    {
        if (is_array($token) && ($token[0] === T_CLASS || $token[0] === T_INTERFACE || $token[0] === T_TRAIT)) {
            return true;
        }
        // We are still here? That should not be.
        return false;
    }

    /**
     * Will return a subset of our main token array. This subset includes all tokens belonging to a certain structure.
     * Might return false on failure
     *
     * @param integer $structureToken The structure we are after e.g. T_CLASS, use PHP tokens here
     *
     * @return array|boolean
     */
    protected function getStructureTokens($structureToken)
    {
        // Now iterate over the array and filter different classes from it
        $result = array();
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // If we got a class keyword, we have to check how far the class extends,
            // then copy the array withing that bounds

            if (is_array($this->tokens[$i]) && $this->tokens[$i][0] === $structureToken && $this->tokens[$i - 1][0] !== T_PAAMAYIM_NEKUDOTAYIM) {
                // The lower bound should be the last semicolon|closing curly bracket|PHP tag before the structure
                $lowerBound = 0;
                for ($j = $i - 1; $j >= 0; $j--) {
                    if ($this->tokens[$j] === ';' || $this->tokens[$j] === '}' ||
                        is_array($this->tokens[$j]) && $this->tokens[$j][0] === T_OPEN_TAG
                    ) {
                        $lowerBound = $j;
                        break;
                    }
                }

                // The upper bound should be the first time the curly brackets are even again
                $upperBound = $this->tokenCount - 1;
                $bracketCounter = null;
                for ($j = $i + 1; $j < count($this->tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($this->tokens[$j] === '{' || $this->tokens[$j][0] === T_CURLY_OPEN) {
                        // If we still got null set to 0
                        if ($bracketCounter === null) {
                            $bracketCounter = 0;
                        }

                        $bracketCounter++;


                    } elseif ($this->tokens[$j] === '}') {
                        // If we still got null set to 0
                        if ($bracketCounter === null) {
                            $bracketCounter = 0;
                        }

                        $bracketCounter--;
                    }

                    // Do we have an even amount of brackets yet?
                    if ($bracketCounter === 0) {
                        $upperBound = $j;
                        break;
                    }
                }

                $result[] = array_slice($this->tokens, $lowerBound, $upperBound - $lowerBound);
            }
        }

        // Last line of defence; did we get something?
        if (empty($result)) {
            return false;
        }

        return $result;
    }

    /**
     * Will return an array of structures which this structure references by use statements
     *
     * @return array
     */
    public function getUsedStructures()
    {
        // Check the tokens
        $structures = array();
        for ($i = 0; $i < $this->tokenCount; $i++) {
            // break as soon as we pass a structure keyword as "use" imports must be globally
            if ($this->isStructureToken($this->tokens[$i])) {
                break;
            }
            // if we got a use statement
            if ($this->tokens[$i][0] === T_USE) {
                $structure = '';
                for ($j = $i + 1; $j < count($this->tokens); $j++) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
                    if ($this->tokens[$j][0] === T_STRING) {
                        $structure .= '\\' . $this->tokens[$j][1];


                    } elseif ($this->tokens[$j] === '{' ||
                        $this->tokens[$j] === ';' ||
                        $this->tokens[$j][0] === T_CURLY_OPEN
                    ) {
                        $structures[] = $structure;
                        break;
                    }
                }
            }
        }

        // Return what we did or did not found
        return $structures;
    }

    /**
     * Will check if a certain structure was mentioned in one(!) use statement.
     *
     * @param StructureDefinitionInterface $structureDefinition The structure $structureName is compared against
     * @param string                       $structureName       The name of the structure we have to check against the
     *                                                          use statements of the definition
     *
     * @return string
     */
    protected function resolveUsedNamespace(StructureDefinitionInterface & $structureDefinition, $structureName)
    {
        // If there was no useful name passed we can fail right here
        if (empty($structureName)) {
            return '';
        }

        // Walk over all namespaces and if we find something we will act accordingly.
        $result = $structureDefinition->getQualifiedName();
        foreach ($structureDefinition->getUsedStructures() as $key => $usedStructures) {
            // Check if the last part of the use statement is our structure
            $tmp = explode('\\', $usedStructures);
            if (array_pop($tmp) === $structureName) {
                // Tell them we succeeded
                return trim(implode('\\', $tmp) . '\\' . $structureName, '\\');
            }
        }

        // We did not seem to have found anything. Might it be that we are in our own namespace?
        if ($structureDefinition->getNamespace() !== null && strpos($structureName, '\\') !== 0) {
            return $structureDefinition->getNamespace() . '\\' . $structureName;
        }

        // Still here? Return what we got.
        return $result;
    }
}


appserver-io / doppelgaenger

Issues (245)

Security Analysis no request data

src/Parser/AbstractStructureParser.php (29 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like