Issues in class-backup-engine-file-zip.php (master) - Issues in master - humanmade/backupwordpress - Measure and Improve Code Quality continuously with Scrutinizer

Issues (217)

Security Analysis no vulnerabilities found

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.

classes/backup/class-backup-engine-file-zip.php (5 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

namespace HM\BackUpWordPress;

use Symfony\Component\Process\Process as Process;

/**
 * Perform a file backup using the zip cli command
 */
class Zip_File_Backup_Engine extends File_Backup_Engine {

	/**
	 * The path to the zip executable
	 *
	 * @var string
	 */
	private $zip_executable_path = '';

	public function __construct() {
		parent::__construct();
	}

	/**
	 * Calculate the path to the zip executable.
	 *
	 * The executable path can be overridden using either the `HMBKP_ZIP_PATH`
	 * Constant or the `hmbkp_zip_executable_path` filter.
	 *
	 * If neither of those are set then we fallback to checking a number of
	 * common locations.
	 *
	 * @return string|false The path to the executable or false.
	 */
	public function get_zip_executable_path() {

		if ( defined( 'HMBKP_ZIP_PATH' ) ) {
			return HMBKP_ZIP_PATH;
		}

		/**
		 * Allow the executable path to be set via a filter
		 *
		 * @param string The path to the zip executable
		 */
		$this->zip_executable_path = apply_filters( 'hmbkp_zip_executable_path', '' );

		if ( ! $this->zip_executable_path ) {

			// List of possible zip locations
			$paths = array(
				'zip',
				'/usr/bin/zip',
				'/usr/local/bin/zip',
				'/opt/local/bin/zip',
			);

			$this->zip_executable_path = Backup_Utilities::get_executable_path( $paths );
class Id
{
    public $id;

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

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

		}

		return $this->zip_executable_path;

	}

	/**
	 * Perform the file backup.
	 *
	 * @return bool Whether the backup completed successfully or not.
	 */
	public function backup() {

		if ( ! $this->get_zip_executable_path() ) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
			return false;
		}

		// cd to the site root
		$command[] = 'cd ' . escapeshellarg( Path::get_root() );
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}

		// Run the zip command with the recursive and quiet flags
		$command[] = '&& ' . escapeshellcmd( $this->get_zip_executable_path() ) . ' -rq';

		// Save the zip file to the correct path
		$command[] = escapeshellarg( $this->get_backup_filepath() ) . ' ./';

		// Pass exclude rules in if we have them
		if ( $this->get_exclude_string() ) {
			$command[] = '-x ' . $this->get_exclude_string();
		}

		$command = implode( ' ', $command );

		$process = new Process( $command );
		$process->setTimeout( HOUR_IN_SECONDS );

		try {
			$process->run();
		} catch ( \Exception $e ) {
			$this->error( __CLASS__, $e->getMessage() );
		}

		if ( ! $process->isSuccessful() ) {

			/**
			 * Exit Code 18 is returned when an unreadable file is encountered during the zip process.
			 *
			 * Given the zip process still completes correctly and the unreadable file is simple skipped
			 * we don't want to treat 18 as an actual error.
			 */
			if ( $process->getExitCode() !== 18 ) {
				$this->error( __CLASS__, $process->getErrorOutput() );
			}
		}

		return $this->verify_backup();

	}

	/**
	 * Convert the exclude rules to a format zip accepts
	 *
	 * @return string The exclude string ready to pass to `zip -x`
	 */
	public function get_exclude_string() {

		if ( ! $this->excludes ) {

			return '';
		}

		$excludes = $this->excludes->get_excludes();


		foreach ( $excludes as $key => &$rule ) {

			$file = $absolute = $fragment = false;

			// Files don't end with /
			if ( ! in_array( substr( $rule, - 1 ), array( '\\', '/' ) ) ) {
				$file = true;
			} // If rule starts with a / then treat as absolute path
			elseif ( in_array( substr( $rule, 0, 1 ), array( '\\', '/' ) ) ) {
				$absolute = true;
			} // Otherwise treat as dir fragment
			else {
				$fragment = true;
			}

			$rule = str_ireplace( Path::get_root(), '', untrailingslashit( wp_normalize_path( $rule ) ) );

			// Strip the preceeding slash
			if ( in_array( substr( $rule, 0, 1 ), array( '\\', '/' ) ) ) {
				$rule = substr( $rule, 1 );
			}

			// Wrap directory fragments and files in wildcards for zip
			if ( $fragment || $file ) {
				$rule = '*' . $rule . '*';
			}

			// Add a wildcard to the end of absolute url for zips
			if ( $absolute ) {
				$rule .= '*';
			}
		}

		// Escape shell args for zip command
		$excludes = array_map( 'escapeshellarg', array_unique( $excludes ) );

		return implode( ' -x ', $excludes );

	}
}


1		<?php
2
3		namespace HM\BackUpWordPress;
4
5		use Symfony\Component\Process\Process as Process;
6
7		/**
8		* Perform a file backup using the zip cli command
9		*/
10		class Zip_File_Backup_Engine extends File_Backup_Engine {
11
12		/**
13		* The path to the zip executable
14		*
15		* @var string
16		*/
17		private $zip_executable_path = '';
18
19		public function __construct() {
20		parent::__construct();
21		}
22
23		/**
24		* Calculate the path to the zip executable.
25		*
26		* The executable path can be overridden using either the `HMBKP_ZIP_PATH`
27		* Constant or the `hmbkp_zip_executable_path` filter.
28		*
29		* If neither of those are set then we fallback to checking a number of
30		* common locations.
31		*
32		* @return string\|false The path to the executable or false.
33		*/
34		public function get_zip_executable_path() {
35
36		if ( defined( 'HMBKP_ZIP_PATH' ) ) {
37		return HMBKP_ZIP_PATH;
38		}
39
40		/**
41		* Allow the executable path to be set via a filter
42		*
43		* @param string The path to the zip executable
44		*/
45		$this->zip_executable_path = apply_filters( 'hmbkp_zip_executable_path', '' );
46
47		if ( ! $this->zip_executable_path ) {
48
49		// List of possible zip locations
50		$paths = array(
51		'zip',
52		'/usr/bin/zip',
53		'/usr/local/bin/zip',
54		'/opt/local/bin/zip',
55		);
56
57		$this->zip_executable_path = Backup_Utilities::get_executable_path( $paths );
		0 ignored issues – show Documentation Bug introduced 2015-11-22 13:57 UTC by Report Bug Copy Issue Report Show Similar Issues like this It seems like `\HM\BackUpWordPress\Back...executable_path($paths)` can also be of type `false`. However, the property `$zip_executable_path` is declared as type `string`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
58
59		}
60
61		return $this->zip_executable_path;
62
63		}
64
65		/**
66		* Perform the file backup.
67		*
68		* @return bool Whether the backup completed successfully or not.
69		*/
70		public function backup() {
71
72		if ( ! $this->get_zip_executable_path() ) {
		0 ignored issues – show Bug Best Practice introduced 2016-02-28 17:47 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `$this->get_zip_executable_path()` of type `string\|false` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
73		return false;
74		}
75
76		// cd to the site root
77		$command[] = 'cd ' . escapeshellarg( Path::get_root() );
		0 ignored issues – show Coding Style Comprehensibility introduced 2015-11-21 01:52 UTC by Report Bug Copy Issue Report Show Similar Issues like this `$command` was never initialized. Although not strictly required by PHP, it is generally a good practice to add `$command = array();` before regardless. Adding an explicit array definition is generally preferable to implicit array definition as it guarantees a stable state of the code. Let’s take a look at an example: foreach ($collection as $item) { $myArray['foo'] = $item->getFoo(); if ($item->hasBar()) { $myArray['bar'] = $item->getBar(); } // do something with $myArray } As you can see in this example, the array `$myArray` is initialized the first time when the foreach loop is entered. You can also see that the value of the `bar` key is only written conditionally; thus, its value might result from a previous iteration. This might or might not be intended. To make your intention clear, your code more readible and to avoid accidental bugs, we recommend to add an explicit initialization `$myArray = array()` either outside or inside the foreach loop. Loading history...
78
79		// Run the zip command with the recursive and quiet flags
80		$command[] = '&& ' . escapeshellcmd( $this->get_zip_executable_path() ) . ' -rq';
81
82		// Save the zip file to the correct path
83		$command[] = escapeshellarg( $this->get_backup_filepath() ) . ' ./';
84
85		// Pass exclude rules in if we have them
86		if ( $this->get_exclude_string() ) {
87		$command[] = '-x ' . $this->get_exclude_string();
88		}
89
90		$command = implode( ' ', $command );
91
92		$process = new Process( $command );
93		$process->setTimeout( HOUR_IN_SECONDS );
94
95		try {
96		$process->run();
97		} catch ( \Exception $e ) {
98		$this->error( __CLASS__, $e->getMessage() );
99		}
100
101		if ( ! $process->isSuccessful() ) {
102
103		/**
104		* Exit Code 18 is returned when an unreadable file is encountered during the zip process.
105		*
106		* Given the zip process still completes correctly and the unreadable file is simple skipped
107		* we don't want to treat 18 as an actual error.
108		*/
109		if ( $process->getExitCode() !== 18 ) {
110		$this->error( __CLASS__, $process->getErrorOutput() );
111		}
112		}
113
114		return $this->verify_backup();
115
116		}
117
118		/**
119		* Convert the exclude rules to a format zip accepts
120		*
121		* @return string The exclude string ready to pass to `zip -x`
122		*/
123		public function get_exclude_string() {
124
125		if ( ! $this->excludes ) {
		0 ignored issues – show Bug Best Practice introduced 2015-11-30 00:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this The expression `$this->excludes` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
126		return '';
127		}
128
129		$excludes = $this->excludes->get_excludes();
		0 ignored issues – show Bug introduced 2015-11-30 00:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this The method `get_excludes` cannot be called on `$this->excludes` (of type `array`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
130
131		foreach ( $excludes as $key => &$rule ) {
132
133		$file = $absolute = $fragment = false;
134
135		// Files don't end with /
136		if ( ! in_array( substr( $rule, - 1 ), array( '\\', '/' ) ) ) {
137		$file = true;
138		} // If rule starts with a / then treat as absolute path
139	View Code Duplication	elseif ( in_array( substr( $rule, 0, 1 ), array( '\\', '/' ) ) ) {
140		$absolute = true;
141		} // Otherwise treat as dir fragment
142		else {
143		$fragment = true;
144		}
145
146		$rule = str_ireplace( Path::get_root(), '', untrailingslashit( wp_normalize_path( $rule ) ) );
147
148		// Strip the preceeding slash
149	View Code Duplication	if ( in_array( substr( $rule, 0, 1 ), array( '\\', '/' ) ) ) {
150		$rule = substr( $rule, 1 );
151		}
152
153		// Wrap directory fragments and files in wildcards for zip
154		if ( $fragment \|\| $file ) {
155		$rule = '' . $rule . '';
156		}
157
158		// Add a wildcard to the end of absolute url for zips
159		if ( $absolute ) {
160		$rule .= '*';
161		}
162		}
163
164		// Escape shell args for zip command
165		$excludes = array_map( 'escapeshellarg', array_unique( $excludes ) );
166
167		return implode( ' -x ', $excludes );
168
169		}
170		}
171

GitHub Access Token became invalid

Issues (217)

Security Analysis no vulnerabilities found

classes/backup/class-backup-engine-file-zip.php (5 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

humanmade / backupwordpress

GitHub Access Token became invalid

Issues (217)

Security Analysis no vulnerabilities found

classes/backup/class-backup-engine-file-zip.php (5 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like