OC\Files\Storage\Wrapper\Encryption::fopen()

Complexity

Conditions	30
Paths	6589

Size

Total Lines

119

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
	public function fopen($path, $mode) {

		// check if the file is stored in the array cache, this means that we
		// copy a file over to the versions folder, in this case we don't want to
		// decrypt it
		if ($this->arrayCache->hasKey('encryption_copy_version_' . $path)) {
			$this->arrayCache->remove('encryption_copy_version_' . $path);
			return $this->storage->fopen($path, $mode);
		}

		$encryptionEnabled = $this->encryptionManager->isEnabled();
		$shouldEncrypt = false;
		$encryptionModule = null;
		$header = $this->getHeader($path);
		$signed = (isset($header['signed']) && $header['signed'] === 'true') ? true : false;
		$fullPath = $this->getFullPath($path);
		$encryptionModuleId = $this->util->getEncryptionModuleId($header);

		if ($this->util->isExcluded($fullPath) === false) {
			$size = $unencryptedSize = 0;
			$realFile = $this->util->stripPartialFileExtension($path);
			$targetExists = $this->file_exists($realFile) || $this->file_exists($path);
			$targetIsEncrypted = false;
			if ($targetExists) {
				// in case the file exists we require the explicit module as
				// specified in the file header - otherwise we need to fail hard to
				// prevent data loss on client side
				if (!empty($encryptionModuleId)) {
					$targetIsEncrypted = true;
					$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
				}

				if ($this->file_exists($path)) {
					$size = $this->storage->filesize($path);
					$unencryptedSize = $this->filesize($path);
				} else {
					$size = $unencryptedSize = 0;
				}
			}

			try {
				if (
					$mode === 'w'
					|| $mode === 'w+'
					|| $mode === 'wb'
					|| $mode === 'wb+'
				) {
					// don't overwrite encrypted files if encryption is not enabled
					if ($targetIsEncrypted && $encryptionEnabled === false) {
						throw new GenericEncryptionException('Tried to access encrypted file but encryption is not enabled');
					}
					if ($encryptionEnabled) {
						// if $encryptionModuleId is empty, the default module will be used
						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
						$shouldEncrypt = $encryptionModule->shouldEncrypt($fullPath);
						$signed = true;
					}
				} else {
					$info = $this->getCache()->get($path);
					// only get encryption module if we found one in the header
					// or if file should be encrypted according to the file cache
					if (!empty($encryptionModuleId)) {
						$encryptionModule = $this->encryptionManager->getEncryptionModule($encryptionModuleId);
						$shouldEncrypt = true;
					} elseif (empty($encryptionModuleId) && $info['encrypted'] === true) {
						// we come from a old installation. No header and/or no module defined
						// but the file is encrypted. In this case we need to use the
						// OC_DEFAULT_MODULE to read the file
						$encryptionModule = $this->encryptionManager->getEncryptionModule('OC_DEFAULT_MODULE');
						$shouldEncrypt = true;
						$targetIsEncrypted = true;
					}
				}
			} catch (ModuleDoesNotExistsException $e) {
				$this->logger->warning('Encryption module "' . $encryptionModuleId .
					'" not found, file will be stored unencrypted (' . $e->getMessage() . ')');
			}

			// encryption disabled on write of new file and write to existing unencrypted file -> don't encrypt
			if (!$encryptionEnabled || !$this->mount->getOption('encrypt', true)) {
				if (!$targetExists || !$targetIsEncrypted) {
					$shouldEncrypt = false;
				}
			}

			if ($shouldEncrypt === true && $encryptionModule !== null) {
				/**
				 * The check of $disableWriteEncryption, required to get the file in the decrypted state.
				 * It will help us get the normal file handler. And hence we can re-encrypt
				 * the file when necessary, later. The true/false of $getDecryptedFile decides whether
				 * to keep the file decrypted or not. The intention is to get the data decrypt
				 * for write mode.
				 */
				if (self::$disableWriteEncryption && ($mode !== 'r')) {
					return $this->getWrapperStorage()->fopen($path, $mode);
				}

				$headerSize = $this->getHeaderSize($path);
				$source = $this->storage->fopen($path, $mode);
				if (!\is_resource($source)) {
					return false;
				}

				if (isset($this->sourcePath[$path])) {
					$sourceFileOfRename = $this->sourcePath[$path];
				} else {
					$sourceFileOfRename = null;
				}
				$handle = \OC\Files\Stream\Encryption::wrap($source, $path, $fullPath, $header,
					$this->uid, $encryptionModule, $this->storage, $this, $this->util, $this->fileHelper, $mode,

$this->fileHelper of type object<OCP\Encryption\IFile> is not a sub-type of object<OC\Encryption\File>. It seems like you assume a concrete implementation of the interface OCP\Encryption\IFile to be always present.

					$size, $unencryptedSize, $headerSize, $signed, $sourceFileOfRename);

It seems like $size defined by $this->storage->filesize($path) on line 399 can also be of type false; however, OC\Files\Stream\Encryption::wrap() does only seem to accept integer, did you maybe forget to handle an error condition?

				unset($this->sourcePath[$path]);

				return $handle;
			}
		}

		return $this->storage->fopen($path, $mode);
	}