Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
93.75% |
15 / 16 |
CRAP | |
99.38% |
159 / 160 |
| filespec | |
0.00% |
0 / 1 |
|
93.75% |
15 / 16 |
78 | |
99.38% |
159 / 160 |
| __construct | |
100.00% |
1 / 1 |
1 | |
100.00% |
8 / 8 |
|||
| set_upload_ary | |
100.00% |
1 / 1 |
7 | |
100.00% |
18 / 18 |
|||
| set_upload_namespace | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| init_error | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| set_error | |
100.00% |
1 / 1 |
1 | |
100.00% |
2 / 2 |
|||
| clean_filename | |
100.00% |
1 / 1 |
7 | |
100.00% |
21 / 21 |
|||
| get | |
100.00% |
1 / 1 |
3 | |
100.00% |
3 / 3 |
|||
| is_image | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| is_uploaded | |
100.00% |
1 / 1 |
8 | |
100.00% |
6 / 6 |
|||
| remove | |
100.00% |
1 / 1 |
2 | |
100.00% |
3 / 3 |
|||
| get_extension | |
100.00% |
1 / 1 |
2 | |
100.00% |
5 / 5 |
|||
| get_mimetype | |
100.00% |
1 / 1 |
3 | |
100.00% |
5 / 5 |
|||
| get_filesize | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| check_content | |
100.00% |
1 / 1 |
5 | |
100.00% |
10 / 10 |
|||
| move_file | |
0.00% |
0 / 1 |
29 | |
98.28% |
57 / 58 |
|||
| additional_checks | |
100.00% |
1 / 1 |
6 | |
100.00% |
16 / 16 |
|||
| <?php | |
| /** | |
| * | |
| * This file is part of the phpBB Forum Software package. | |
| * | |
| * @copyright (c) phpBB Limited <https://www.phpbb.com> | |
| * @license GNU General Public License, version 2 (GPL-2.0) | |
| * | |
| * For full copyright and license information, please see | |
| * the docs/CREDITS.txt file. | |
| * | |
| */ | |
| namespace phpbb\files; | |
| use phpbb\language\language; | |
| /** | |
| * Responsible for holding all file relevant information, as well as doing file-specific operations. | |
| * The {@link fileupload fileupload class} can be used to upload several files, each of them being this object to operate further on. | |
| */ | |
| class filespec | |
| { | |
| /** @var string File name */ | |
| protected $filename = ''; | |
| /** @var string Real name of file */ | |
| protected $realname = ''; | |
| /** @var string Upload name of file */ | |
| protected $uploadname = ''; | |
| /** @var string Mimetype of file */ | |
| protected $mimetype = ''; | |
| /** @var string File extension */ | |
| protected $extension = ''; | |
| /** @var int File size */ | |
| protected $filesize = 0; | |
| /** @var int Width of file */ | |
| protected $width = 0; | |
| /** @var int Height of file */ | |
| protected $height = 0; | |
| /** @var array Image info including type and size */ | |
| protected $image_info = array(); | |
| /** @var string Destination file name */ | |
| protected $destination_file = ''; | |
| /** @var string Destination file path */ | |
| protected $destination_path = ''; | |
| /** @var bool Whether file was moved */ | |
| protected $file_moved = false; | |
| /** @var bool Whether file is local */ | |
| protected $local = false; | |
| /** @var bool Class initialization flag */ | |
| protected $class_initialized = false; | |
| /** @var array Error array */ | |
| public $error = array(); | |
| /** @var upload Instance of upload class */ | |
| public $upload; | |
| /** @var \phpbb\filesystem\filesystem_interface */ | |
| protected $filesystem; | |
| /** @var \bantu\IniGetWrapper\IniGetWrapper ini_get() wrapper class */ | |
| protected $php_ini; | |
| /** @var \FastImageSize\FastImageSize */ | |
| protected $imagesize; | |
| /** @var language Language class */ | |
| protected $language; | |
| /** @var string phpBB root path */ | |
| protected $phpbb_root_path; | |
| /** @var \phpbb\plupload\plupload The plupload object */ | |
| protected $plupload; | |
| /** @var \phpbb\mimetype\guesser phpBB Mimetype guesser */ | |
| protected $mimetype_guesser; | |
| /** | |
| * File upload class | |
| * | |
| * @param \phpbb\filesystem\filesystem_interface $phpbb_filesystem Filesystem | |
| * @param language $language Language | |
| * @param \bantu\IniGetWrapper\IniGetWrapper $php_ini ini_get() wrapper | |
| * @param \FastImageSize\FastImageSize $imagesize Imagesize class | |
| * @param string $phpbb_root_path phpBB root path | |
| * @param \phpbb\mimetype\guesser $mimetype_guesser Mime type guesser | |
| * @param \phpbb\plupload\plupload $plupload Plupload | |
| */ | |
| public function __construct(\phpbb\filesystem\filesystem_interface $phpbb_filesystem, language $language, \bantu\IniGetWrapper\IniGetWrapper $php_ini, \FastImageSize\FastImageSize $imagesize, $phpbb_root_path, \phpbb\mimetype\guesser $mimetype_guesser = null, \phpbb\plupload\plupload $plupload = null) | |
| { | |
| $this->filesystem = $phpbb_filesystem; | |
| $this->language = $language; | |
| $this->php_ini = $php_ini; | |
| $this->imagesize = $imagesize; | |
| $this->phpbb_root_path = $phpbb_root_path; | |
| $this->plupload = $plupload; | |
| $this->mimetype_guesser = $mimetype_guesser; | |
| } | |
| /** | |
| * Set upload ary | |
| * | |
| * @param array $upload_ary Upload ary | |
| * | |
| * @return filespec This instance of the filespec class | |
| */ | |
| public function set_upload_ary($upload_ary) | |
| { | |
| if (!isset($upload_ary) || !count($upload_ary)) | |
| { | |
| return $this; | |
| } | |
| $this->class_initialized = true; | |
| $this->filename = $upload_ary['tmp_name']; | |
| $this->filesize = $upload_ary['size']; | |
| $name = $upload_ary['name']; | |
| $name = trim(utf8_basename($name)); | |
| $this->realname = $this->uploadname = $name; | |
| $this->mimetype = $upload_ary['type']; | |
| // Opera adds the name to the mime type | |
| $this->mimetype = (strpos($this->mimetype, '; name') !== false) ? str_replace(strstr($this->mimetype, '; name'), '', $this->mimetype) : $this->mimetype; | |
| if (!$this->mimetype) | |
| { | |
| $this->mimetype = 'application/octet-stream'; | |
| } | |
| $this->extension = strtolower(self::get_extension($this->realname)); | |
| // Try to get real filesize from temporary folder (not always working) ;) | |
| $this->filesize = ($this->get_filesize($this->filename)) ?: $this->filesize; | |
| $this->width = $this->height = 0; | |
| $this->file_moved = false; | |
| $this->local = (isset($upload_ary['local_mode'])) ? true : false; | |
| return $this; | |
| } | |
| /** | |
| * Set the upload namespace | |
| * | |
| * @param upload $namespace Instance of upload class | |
| * | |
| * @return filespec This instance of the filespec class | |
| */ | |
| public function set_upload_namespace($namespace) | |
| { | |
| $this->upload = $namespace; | |
| return $this; | |
| } | |
| /** | |
| * Check if class members were not properly initialised yet | |
| * | |
| * @return bool True if there was an init error, false if not | |
| */ | |
| public function init_error() | |
| { | |
| return !$this->class_initialized; | |
| } | |
| /** | |
| * Set error in error array | |
| * | |
| * @param mixed $error Content for error array | |
| * | |
| * @return \phpbb\files\filespec This instance of the filespec class | |
| */ | |
| public function set_error($error) | |
| { | |
| $this->error[] = $error; | |
| return $this; | |
| } | |
| /** | |
| * Cleans destination filename | |
| * | |
| * @param string $mode Either real, unique, or unique_ext. Real creates a | |
| * realname, filtering some characters, lowering every | |
| * character. Unique creates a unique filename. | |
| * @param string $prefix Prefix applied to filename | |
| * @param string $user_id The user_id is only needed for when cleaning a user's avatar | |
| */ | |
| public function clean_filename($mode = 'unique', $prefix = '', $user_id = '') | |
| { | |
| if ($this->init_error()) | |
| { | |
| return; | |
| } | |
| switch ($mode) | |
| { | |
| case 'real': | |
| // Remove every extension from filename (to not let the mime bug being exposed) | |
| if (strpos($this->realname, '.') !== false) | |
| { | |
| $this->realname = substr($this->realname, 0, strpos($this->realname, '.')); | |
| } | |
| // Replace any chars which may cause us problems with _ | |
| $bad_chars = array("'", "\\", ' ', '/', ':', '*', '?', '"', '<', '>', '|'); | |
| $this->realname = rawurlencode(str_replace($bad_chars, '_', strtolower($this->realname))); | |
| $this->realname = preg_replace("/%(\w{2})/", '_', $this->realname); | |
| $this->realname = $prefix . $this->realname . '.' . $this->extension; | |
| break; | |
| case 'unique': | |
| $this->realname = $prefix . md5(unique_id()); | |
| break; | |
| case 'avatar': | |
| $this->extension = strtolower($this->extension); | |
| $this->realname = $prefix . $user_id . '.' . $this->extension; | |
| break; | |
| case 'unique_ext': | |
| default: | |
| $this->realname = $prefix . md5(unique_id()) . '.' . $this->extension; | |
| } | |
| } | |
| /** | |
| * Get property from file object | |
| * | |
| * @param string $property Name of property | |
| * | |
| * @return mixed Content of property | |
| */ | |
| public function get($property) | |
| { | |
| if ($this->init_error() || !isset($this->$property)) | |
| { | |
| return false; | |
| } | |
| return $this->$property; | |
| } | |
| /** | |
| * Check if file is an image (mime type) | |
| * | |
| * @return bool true if it is an image, false if not | |
| */ | |
| public function is_image() | |
| { | |
| return (strpos($this->mimetype, 'image/') === 0); | |
| } | |
| /** | |
| * Check if the file got correctly uploaded | |
| * | |
| * @return bool true if it is a valid upload, false if not | |
| */ | |
| public function is_uploaded() | |
| { | |
| $is_plupload = $this->plupload && $this->plupload->is_active(); | |
| if (!$this->local && !$is_plupload && !is_uploaded_file($this->filename)) | |
| { | |
| return false; | |
| } | |
| if (($this->local || $is_plupload) && !file_exists($this->filename)) | |
| { | |
| return false; | |
| } | |
| return true; | |
| } | |
| /** | |
| * Remove file | |
| */ | |
| public function remove() | |
| { | |
| if ($this->file_moved) | |
| { | |
| @unlink($this->destination_file); | |
| } | |
| } | |
| /** | |
| * Get file extension | |
| * | |
| * @param string $filename Filename that needs to be checked | |
| * | |
| * @return string Extension of the supplied filename | |
| */ | |
| static public function get_extension($filename) | |
| { | |
| $filename = utf8_basename($filename); | |
| if (strpos($filename, '.') === false) | |
| { | |
| return ''; | |
| } | |
| $filename = explode('.', $filename); | |
| return array_pop($filename); | |
| } | |
| /** | |
| * Get mime type | |
| * | |
| * @param string $filename Filename that needs to be checked | |
| * @return string Mime type of supplied filename | |
| */ | |
| public function get_mimetype($filename) | |
| { | |
| if ($this->mimetype_guesser !== null) | |
| { | |
| $mimetype = $this->mimetype_guesser->guess($filename, $this->uploadname); | |
| if ($mimetype !== 'application/octet-stream') | |
| { | |
| $this->mimetype = $mimetype; | |
| } | |
| } | |
| return $this->mimetype; | |
| } | |
| /** | |
| * Get file size | |
| * | |
| * @param string $filename File name of file to check | |
| * | |
| * @return int File size | |
| */ | |
| public function get_filesize($filename) | |
| { | |
| return @filesize($filename); | |
| } | |
| /** | |
| * Check the first 256 bytes for forbidden content | |
| * | |
| * @param array $disallowed_content Array containg disallowed content | |
| * | |
| * @return bool False if disallowed content found, true if not | |
| */ | |
| public function check_content($disallowed_content) | |
| { | |
| if (empty($disallowed_content)) | |
| { | |
| return true; | |
| } | |
| $fp = @fopen($this->filename, 'rb'); | |
| if ($fp !== false) | |
| { | |
| $ie_mime_relevant = fread($fp, 256); | |
| fclose($fp); | |
| foreach ($disallowed_content as $forbidden) | |
| { | |
| if (stripos($ie_mime_relevant, '<' . $forbidden) !== false) | |
| { | |
| return false; | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| /** | |
| * Move file to destination folder | |
| * The phpbb_root_path variable will be applied to the destination path | |
| * | |
| * @param string $destination Destination path, for example $config['avatar_path'] | |
| * @param bool $overwrite If set to true, an already existing file will be overwritten | |
| * @param bool $skip_image_check If set to true, the check for the file to be a valid image is skipped | |
| * @param string|bool $chmod Permission mask for chmodding the file after a successful move. | |
| * The mode entered here reflects the mode defined by {@link phpbb_chmod()} | |
| * | |
| * @return bool True if file was moved, false if not | |
| * @access public | |
| */ | |
| public function move_file($destination, $overwrite = false, $skip_image_check = false, $chmod = false) | |
| { | |
| if (count($this->error)) | |
| { | |
| return false; | |
| } | |
| $chmod = ($chmod === false) ? \phpbb\filesystem\filesystem_interface::CHMOD_READ | \phpbb\filesystem\filesystem_interface::CHMOD_WRITE : $chmod; | |
| // We need to trust the admin in specifying valid upload directories and an attacker not being able to overwrite it... | |
| $this->destination_path = $this->phpbb_root_path . $destination; | |
| // Check if the destination path exist... | |
| if (!file_exists($this->destination_path)) | |
| { | |
| @unlink($this->filename); | |
| return false; | |
| } | |
| $upload_mode = ($this->php_ini->getBool('open_basedir')) ? 'move' : 'copy'; | |
| $upload_mode = ($this->local) ? 'local' : $upload_mode; | |
| $this->destination_file = $this->destination_path . '/' . utf8_basename($this->realname); | |
| // Check if the file already exist, else there is something wrong... | |
| if (file_exists($this->destination_file) && !$overwrite) | |
| { | |
| @unlink($this->filename); | |
| $this->error[] = $this->language->lang($this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR', $this->destination_file); | |
| $this->file_moved = false; | |
| return false; | |
| } | |
| else | |
| { | |
| if (file_exists($this->destination_file)) | |
| { | |
| @unlink($this->destination_file); | |
| } | |
| switch ($upload_mode) | |
| { | |
| case 'copy': | |
| if (!@copy($this->filename, $this->destination_file)) | |
| { | |
| if (!@move_uploaded_file($this->filename, $this->destination_file)) | |
| { | |
| $this->error[] = $this->language->lang($this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR', $this->destination_file); | |
| } | |
| } | |
| break; | |
| case 'move': | |
| if (!@move_uploaded_file($this->filename, $this->destination_file)) | |
| { | |
| if (!@copy($this->filename, $this->destination_file)) | |
| { | |
| $this->error[] = $this->language->lang($this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR', $this->destination_file); | |
| } | |
| } | |
| break; | |
| case 'local': | |
| if (!@copy($this->filename, $this->destination_file)) | |
| { | |
| $this->error[] = $this->language->lang($this->upload->error_prefix . 'GENERAL_UPLOAD_ERROR', $this->destination_file); | |
| } | |
| break; | |
| } | |
| // Remove temporary filename | |
| if (file_exists($this->filename)) | |
| { | |
| @unlink($this->filename); | |
| } | |
| if (count($this->error)) | |
| { | |
| return false; | |
| } | |
| try | |
| { | |
| $this->filesystem->phpbb_chmod($this->destination_file, $chmod); | |
| } | |
| catch (\phpbb\filesystem\exception\filesystem_exception $e) | |
| { | |
| // Do nothing | |
| } | |
| } | |
| // Try to get real filesize from destination folder | |
| $this->filesize = ($this->get_filesize($this->destination_file)) ?: $this->filesize; | |
| // Get mimetype of supplied file | |
| $this->mimetype = $this->get_mimetype($this->destination_file); | |
| if ($this->is_image() && !$skip_image_check) | |
| { | |
| $this->width = $this->height = 0; | |
| $this->image_info = $this->imagesize->getImageSize($this->destination_file, $this->mimetype); | |
| if ($this->image_info !== false) | |
| { | |
| $this->width = $this->image_info['width']; | |
| $this->height = $this->image_info['height']; | |
| // Check image type | |
| $types = upload::image_types(); | |
| if (!isset($types[$this->image_info['type']]) || !in_array($this->extension, $types[$this->image_info['type']])) | |
| { | |
| if (!isset($types[$this->image_info['type']])) | |
| { | |
| $this->error[] = $this->language->lang('IMAGE_FILETYPE_INVALID', $this->image_info['type'], $this->mimetype); | |
| } | |
| else | |
| { | |
| $this->error[] = $this->language->lang('IMAGE_FILETYPE_MISMATCH', $types[$this->image_info['type']][0], $this->extension); | |
| } | |
| } | |
| // Make sure the dimensions match a valid image | |
| if (empty($this->width) || empty($this->height)) | |
| { | |
| $this->error[] = $this->language->lang('ATTACHED_IMAGE_NOT_IMAGE'); | |
| } | |
| } | |
| else | |
| { | |
| $this->error[] = $this->language->lang('UNABLE_GET_IMAGE_SIZE'); | |
| } | |
| } | |
| $this->file_moved = true; | |
| $this->additional_checks(); | |
| unset($this->upload); | |
| return true; | |
| } | |
| /** | |
| * Performing additional checks | |
| * | |
| * @return bool False if issue was found, true if not | |
| */ | |
| public function additional_checks() | |
| { | |
| if (!$this->file_moved) | |
| { | |
| return false; | |
| } | |
| // Filesize is too big or it's 0 if it was larger than the maxsize in the upload form | |
| if ($this->upload->max_filesize && ($this->get('filesize') > $this->upload->max_filesize || $this->filesize == 0)) | |
| { | |
| $max_filesize = get_formatted_filesize($this->upload->max_filesize, false); | |
| $this->error[] = $this->language->lang($this->upload->error_prefix . 'WRONG_FILESIZE', $max_filesize['value'], $max_filesize['unit']); | |
| return false; | |
| } | |
| if (!$this->upload->valid_dimensions($this)) | |
| { | |
| $this->error[] = $this->language->lang($this->upload->error_prefix . 'WRONG_SIZE', | |
| $this->language->lang('PIXELS', (int) $this->upload->min_width), | |
| $this->language->lang('PIXELS', (int) $this->upload->min_height), | |
| $this->language->lang('PIXELS', (int) $this->upload->max_width), | |
| $this->language->lang('PIXELS', (int) $this->upload->max_height), | |
| $this->language->lang('PIXELS', (int) $this->width), | |
| $this->language->lang('PIXELS', (int) $this->height)); | |
| return false; | |
| } | |
| return true; | |
| } | |
| } |