nextcloud/apps/files_encryption/lib/proxy.php

470 lines
11 KiB
PHP
Raw Normal View History

2011-10-21 19:02:11 +04:00
<?php
/**
2013-05-20 03:24:36 +04:00
* ownCloud
*
* @author Sam Tuke, Robin Appelman
* @copyright 2012 Sam Tuke samtuke@owncloud.com, Robin Appelman
* icewind1991@gmail.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU AFFERO GENERAL PUBLIC LICENSE for more details.
*
* You should have received a copy of the GNU Affero General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
*/
2011-10-21 19:02:11 +04:00
/**
2013-05-20 03:24:36 +04:00
* @brief Encryption proxy which handles filesystem operations before and after
* execution and encrypts, and handles keyfiles accordingly. Used for
* webui.
*/
namespace OCA\Encryption;
2013-05-20 03:24:36 +04:00
/**
* Class Proxy
* @package OCA\Encryption
*/
2013-05-27 19:26:58 +04:00
class Proxy extends \OC_FileProxy {
private static $blackList = null; //mimetypes blacklisted from encryption
2013-05-20 03:24:36 +04:00
private static $enableEncryption = null;
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
/**
* Check if a file requires encryption
2011-11-24 04:44:54 +04:00
* @param string $path
* @return bool
*
* Tests if server side encryption is enabled, and file is allowed by blacklists
2011-11-24 04:44:54 +04:00
*/
2013-05-27 19:26:58 +04:00
private static function shouldEncrypt($path) {
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
if (is_null(self::$enableEncryption)) {
2013-05-20 03:24:36 +04:00
if (
\OCP\Config::getAppValue('files_encryption', 'enable_encryption', 'true') === 'true'
&& Crypt::mode() === 'server'
) {
2013-05-20 03:24:36 +04:00
self::$enableEncryption = true;
2013-05-20 03:24:36 +04:00
} else {
2013-05-20 03:24:36 +04:00
self::$enableEncryption = false;
2013-05-20 03:24:36 +04:00
}
2013-05-20 03:24:36 +04:00
2012-04-18 18:02:35 +04:00
}
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
if (!self::$enableEncryption) {
2013-05-20 03:24:36 +04:00
2012-04-18 18:02:35 +04:00
return false;
2013-05-20 03:24:36 +04:00
2012-04-18 18:02:35 +04:00
}
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
if (is_null(self::$blackList)) {
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
self::$blackList = explode(',', \OCP\Config::getAppValue('files_encryption', 'type_blacklist', ''));
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
}
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
if (Crypt::isCatfileContent($path)) {
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
return true;
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
}
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
$extension = substr($path, strrpos($path, '.') + 1);
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
if (array_search($extension, self::$blackList) === false) {
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
return true;
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
}
2013-05-20 03:24:36 +04:00
return false;
2011-11-24 04:44:54 +04:00
}
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
/**
* @param $path
* @param $data
* @return bool
*/
2013-05-27 19:26:58 +04:00
public function preFile_put_contents($path, &$data) {
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
if (self::shouldEncrypt($path)) {
2013-04-23 21:08:52 +04:00
// Stream put contents should have been converted to fopen
2013-05-27 19:26:58 +04:00
if (!is_resource($data)) {
2013-04-23 21:08:52 +04:00
$userId = \OCP\USER::getUser();
2013-05-27 19:26:58 +04:00
$view = new \OC_FilesystemView('/');
$util = new Util($view, $userId);
$session = new Session($view);
$privateKey = $session->getPrivateKey();
2013-05-27 19:26:58 +04:00
$filePath = $util->stripUserFilesPath($path);
// Set the filesize for userland, before encrypting
2013-05-27 19:26:58 +04:00
$size = strlen($data);
2013-05-20 03:24:36 +04:00
// Disable encryption proxy to prevent recursive calls
$proxyStatus = \OC_FileProxy::$enabled;
\OC_FileProxy::$enabled = false;
2013-05-20 03:24:36 +04:00
// Check if there is an existing key we can reuse
2013-05-27 19:26:58 +04:00
if ($encKeyfile = Keymanager::getFileKey($view, $userId, $filePath)) {
2013-05-20 03:24:36 +04:00
// Fetch shareKey
2013-05-27 19:26:58 +04:00
$shareKey = Keymanager::getShareKey($view, $userId, $filePath);
2013-05-20 03:24:36 +04:00
// Decrypt the keyfile
2013-05-27 19:26:58 +04:00
$plainKey = Crypt::multiKeyDecrypt($encKeyfile, $shareKey, $privateKey);
2013-05-20 03:24:36 +04:00
} else {
2013-05-20 03:24:36 +04:00
// Make a new key
$plainKey = Crypt::generateKey();
2013-05-20 03:24:36 +04:00
}
2013-05-20 03:24:36 +04:00
// Encrypt data
2013-05-27 19:26:58 +04:00
$encData = Crypt::symmetricEncryptFileContent($data, $plainKey);
2013-05-20 03:24:36 +04:00
$sharingEnabled = \OCP\Share::isEnabled();
2013-05-16 02:31:17 +04:00
// if file exists try to get sharing users
2013-05-27 19:26:58 +04:00
if ($view->file_exists($path)) {
$uniqueUserIds = $util->getSharingUsersArray($sharingEnabled, $filePath, $userId);
2013-05-16 02:31:17 +04:00
} else {
$uniqueUserIds[] = $userId;
}
2013-04-23 21:08:52 +04:00
// Fetch public keys for all users who will share the file
2013-05-27 19:26:58 +04:00
$publicKeys = Keymanager::getPublicKeys($view, $uniqueUserIds);
// Encrypt plain keyfile to multiple sharefiles
2013-05-27 19:26:58 +04:00
$multiEncrypted = Crypt::multiKeyEncrypt($plainKey, $publicKeys);
2013-05-20 03:24:36 +04:00
// Save sharekeys to user folders
2013-05-27 19:26:58 +04:00
Keymanager::setShareKeys($view, $filePath, $multiEncrypted['keys']);
2013-05-20 03:24:36 +04:00
// Set encrypted keyfile as common varname
$encKey = $multiEncrypted['data'];
2013-05-20 03:24:36 +04:00
// Save keyfile for newly encrypted file in parallel directory tree
2013-05-27 19:26:58 +04:00
Keymanager::setFileKey($view, $filePath, $userId, $encKey);
// Replace plain content with encrypted content by reference
$data = $encData;
2013-05-20 03:24:36 +04:00
// Update the file cache with file info
2013-05-27 19:26:58 +04:00
\OC\Files\Filesystem::putFileInfo($filePath, array(
'encrypted' => true,
'size' => strlen($data),
'unencrypted_size' => $size
), '');
2013-04-30 22:44:42 +04:00
// Re-enable proxy - our work is done
\OC_FileProxy::$enabled = $proxyStatus;
2013-05-20 03:24:36 +04:00
2011-10-21 19:02:11 +04:00
}
}
2013-04-23 21:08:52 +04:00
return true;
2013-05-20 03:24:36 +04:00
}
2013-05-20 03:24:36 +04:00
/**
* @param string $path Path of file from which has been read
* @param string $data Data that has been read from file
*/
2013-05-27 19:26:58 +04:00
public function postFile_get_contents($path, $data) {
2013-05-20 03:24:36 +04:00
$userId = \OCP\USER::getUser();
2013-05-27 19:26:58 +04:00
$view = new \OC_FilesystemView('/');
$util = new Util($view, $userId);
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
$relPath = $util->stripUserFilesPath($path);
2013-05-20 03:24:36 +04:00
// Disable encryption proxy to prevent recursive calls
2013-05-20 03:24:36 +04:00
$proxyStatus = \OC_FileProxy::$enabled;
\OC_FileProxy::$enabled = false;
// init session
2013-05-27 19:26:58 +04:00
$session = new Session($view);
2013-05-20 03:24:36 +04:00
// If data is a catfile
if (
Crypt::mode() === 'server'
2013-05-27 19:26:58 +04:00
&& Crypt::isCatfileContent($data)
) {
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
$privateKey = $session->getPrivateKey($userId);
2013-05-20 03:24:36 +04:00
// Get the encrypted keyfile
2013-05-27 19:26:58 +04:00
$encKeyfile = Keymanager::getFileKey($view, $userId, $relPath);
2013-05-20 03:24:36 +04:00
// Attempt to fetch the user's shareKey
2013-05-27 19:26:58 +04:00
$shareKey = Keymanager::getShareKey($view, $userId, $relPath);
2013-05-20 03:24:36 +04:00
// Decrypt keyfile with shareKey
2013-05-27 19:26:58 +04:00
$plainKeyfile = Crypt::multiKeyDecrypt($encKeyfile, $shareKey, $privateKey);
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
$plainData = Crypt::symmetricDecryptFileContent($data, $plainKeyfile);
} elseif (
Crypt::mode() === 'server'
2013-05-27 19:26:58 +04:00
&& isset($_SESSION['legacyenckey'])
&& Crypt::isEncryptedMeta($path)
) {
$plainData = Crypt::legacyBlockDecrypt($data, $session->getLegacyKey());
2011-10-21 19:02:11 +04:00
}
2013-05-20 03:24:36 +04:00
\OC_FileProxy::$enabled = $proxyStatus;
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
if (!isset($plainData)) {
2013-05-20 03:24:36 +04:00
$plainData = $data;
2013-05-20 03:24:36 +04:00
}
2013-05-20 03:24:36 +04:00
return $plainData;
2013-05-20 03:24:36 +04:00
2011-10-21 19:02:11 +04:00
}
2013-05-20 03:24:36 +04:00
/**
* @brief When a file is deleted, remove its keyfile also
*/
2013-05-27 19:26:58 +04:00
public function preUnlink($path) {
2013-05-20 03:24:36 +04:00
2013-04-18 04:03:03 +04:00
// let the trashbin handle this
2013-05-27 19:26:58 +04:00
if (\OCP\App::isEnabled('files_trashbin')) {
2013-05-20 03:24:36 +04:00
return true;
2013-04-18 04:03:03 +04:00
}
2013-05-20 03:24:36 +04:00
// Disable encryption proxy to prevent recursive calls
2013-05-20 03:24:36 +04:00
$proxyStatus = \OC_FileProxy::$enabled;
\OC_FileProxy::$enabled = false;
2013-05-27 19:26:58 +04:00
$view = new \OC_FilesystemView('/');
$userId = \OCP\USER::getUser();
2013-05-27 19:26:58 +04:00
$util = new Util($view, $userId);
// Format path to be relative to user files dir
2013-05-27 19:26:58 +04:00
$relPath = $util->stripUserFilesPath($path);
2013-05-27 19:26:58 +04:00
list($owner, $ownerPath) = $util->getUidAndFilename($relPath);
// Delete keyfile & shareKey so it isn't orphaned
2013-05-27 19:26:58 +04:00
if (!Keymanager::deleteFileKey($view, $owner, $ownerPath)) {
\OC_Log::write('Encryption library',
'Keyfile or shareKey could not be deleted for file "' . $ownerPath . '"', \OC_Log::ERROR);
}
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
Keymanager::delAllShareKeys($view, $owner, $ownerPath);
2013-05-24 01:56:31 +04:00
\OC_FileProxy::$enabled = $proxyStatus;
2013-05-20 03:24:36 +04:00
// If we don't return true then file delete will fail; better
// to leave orphaned keyfiles than to disallow file deletion
return true;
2013-05-20 03:24:36 +04:00
}
2013-05-20 03:24:36 +04:00
/**
* @param $path
* @return bool
*/
2013-05-27 19:26:58 +04:00
public function postTouch($path) {
$this->handleFile($path);
2013-05-20 03:24:36 +04:00
return true;
}
2013-05-20 03:24:36 +04:00
/**
* @param $path
* @param $result
* @return resource
*/
2013-05-27 19:26:58 +04:00
public function postFopen($path, &$result) {
2013-05-27 19:26:58 +04:00
if (!$result) {
2013-04-23 21:08:52 +04:00
2011-11-24 04:44:54 +04:00
return $result;
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
}
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
// Reformat path for use with OC_FSV
2013-05-27 19:26:58 +04:00
$path_split = explode('/', $path);
$path_f = implode('/', array_slice($path_split, 3));
2013-05-20 03:24:36 +04:00
// FIXME: handling for /userId/cache used by webdav for chunking. The cache chunks are NOT encrypted
if (isset($path_split) && $path_split[2] === 'cache') {
2013-05-20 03:24:36 +04:00
return $result;
}
// Disable encryption proxy to prevent recursive calls
2013-05-20 03:24:36 +04:00
$proxyStatus = \OC_FileProxy::$enabled;
\OC_FileProxy::$enabled = false;
2013-05-27 19:26:58 +04:00
$meta = stream_get_meta_data($result);
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
$view = new \OC_FilesystemView('');
2013-05-20 03:24:36 +04:00
2013-05-27 19:26:58 +04:00
$util = new Util($view, \OCP\USER::getUser());
2013-05-20 03:24:36 +04:00
2012-11-22 23:36:48 +04:00
// If file is already encrypted, decrypt using crypto protocol
2013-05-20 03:24:36 +04:00
if (
Crypt::mode() === 'server'
2013-05-27 19:26:58 +04:00
&& $util->isEncryptedPath($path)
) {
2013-05-20 03:24:36 +04:00
2012-11-22 23:36:48 +04:00
// Close the original encrypted file
2013-05-27 19:26:58 +04:00
fclose($result);
2013-05-20 03:24:36 +04:00
// Open the file using the crypto stream wrapper
// protocol and let it do the decryption work instead
2013-05-27 19:26:58 +04:00
$result = fopen('crypt://' . $path_f, $meta['mode']);
2013-05-20 03:24:36 +04:00
} elseif (
2013-05-27 19:26:58 +04:00
self::shouldEncrypt($path)
and $meta ['mode'] !== 'r'
and $meta['mode'] !== 'rb'
) {
2013-05-27 19:26:58 +04:00
$result = fopen('crypt://' . $path_f, $meta['mode']);
2012-11-22 18:08:19 +04:00
}
2013-05-20 03:24:36 +04:00
2012-11-14 17:58:57 +04:00
// Re-enable the proxy
\OC_FileProxy::$enabled = $proxyStatus;
2013-05-20 03:24:36 +04:00
2011-11-24 04:44:54 +04:00
return $result;
2013-05-20 03:24:36 +04:00
2011-10-21 19:02:11 +04:00
}
2012-02-16 00:44:58 +04:00
2013-05-20 03:24:36 +04:00
/**
* @param $path
* @param $data
* @return array
*/
2013-05-27 19:26:58 +04:00
public function postGetFileInfo($path, $data) {
2013-05-20 03:24:36 +04:00
// if path is a folder do nothing
2013-05-27 19:26:58 +04:00
if (is_array($data) && array_key_exists('size', $data)) {
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
// Disable encryption proxy to prevent recursive calls
$proxyStatus = \OC_FileProxy::$enabled;
\OC_FileProxy::$enabled = false;
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
// get file size
2013-05-27 19:26:58 +04:00
$data['size'] = self::postFileSize($path, $data['size']);
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
// Re-enable the proxy
\OC_FileProxy::$enabled = $proxyStatus;
}
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
return $data;
}
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
/**
* @param $path
* @param $size
* @return bool
*/
2013-05-27 19:26:58 +04:00
public function postFileSize($path, $size) {
2013-04-23 21:08:52 +04:00
2013-05-27 19:26:58 +04:00
$view = new \OC_FilesystemView('/');
2013-04-23 21:08:52 +04:00
2013-05-20 03:24:36 +04:00
// if path is a folder do nothing
2013-05-27 19:26:58 +04:00
if ($view->is_dir($path)) {
2013-05-20 03:24:36 +04:00
return $size;
}
2013-05-20 03:24:36 +04:00
// Reformat path for use with OC_FSV
2013-05-27 19:26:58 +04:00
$path_split = explode('/', $path);
$path_f = implode('/', array_slice($path_split, 3));
2013-05-07 15:42:08 +04:00
2013-05-20 03:24:36 +04:00
// if path is empty we cannot resolve anything
2013-05-27 19:26:58 +04:00
if (empty($path_f)) {
2013-05-20 03:24:36 +04:00
return $size;
}
2013-05-21 23:09:25 +04:00
$fileInfo = false;
// get file info from database/cache if not .part file
2013-05-27 19:26:58 +04:00
if (!Keymanager::isPartialFilePath($path)) {
$fileInfo = $view->getFileInfo($path);
2013-05-21 23:09:25 +04:00
}
2013-05-20 03:24:36 +04:00
// if file is encrypted return real file size
2013-05-27 19:26:58 +04:00
if (is_array($fileInfo) && $fileInfo['encrypted'] === true) {
2013-05-20 03:24:36 +04:00
$size = $fileInfo['unencrypted_size'];
} else {
// self healing if file was removed from file cache
2013-05-27 19:26:58 +04:00
if (!is_array($fileInfo)) {
2013-05-21 23:09:25 +04:00
$fileInfo = array();
}
2013-05-20 03:24:36 +04:00
2013-05-21 23:09:25 +04:00
$userId = \OCP\User::getUser();
2013-05-27 19:26:58 +04:00
$util = new Util($view, $userId);
$fixSize = $util->getFileSize($path);
if ($fixSize > 0) {
2013-05-21 23:09:25 +04:00
$size = $fixSize;
2013-05-20 03:24:36 +04:00
2013-05-21 23:09:25 +04:00
$fileInfo['encrypted'] = true;
$fileInfo['unencrypted_size'] = $size;
// put file info if not .part file
2013-05-27 19:26:58 +04:00
if (!Keymanager::isPartialFilePath($path_f)) {
$view->putFileInfo($path, $fileInfo);
2013-05-20 03:24:36 +04:00
}
}
2013-05-21 23:09:25 +04:00
2013-05-20 03:24:36 +04:00
}
return $size;
}
2013-04-30 22:44:42 +04:00
2013-05-20 03:24:36 +04:00
/**
* @param $path
*/
2013-05-27 19:26:58 +04:00
public function handleFile($path) {
2013-04-30 22:44:42 +04:00
2013-05-20 03:24:36 +04:00
// Disable encryption proxy to prevent recursive calls
$proxyStatus = \OC_FileProxy::$enabled;
\OC_FileProxy::$enabled = false;
2013-05-27 19:26:58 +04:00
$view = new \OC_FilesystemView('/');
$session = new Session($view);
2013-05-20 03:24:36 +04:00
$userId = \OCP\User::getUser();
2013-05-27 19:26:58 +04:00
$util = new Util($view, $userId);
2013-05-20 03:24:36 +04:00
// Reformat path for use with OC_FSV
2013-05-27 19:26:58 +04:00
$path_split = explode('/', $path);
$path_f = implode('/', array_slice($path_split, 3));
2013-05-20 03:24:36 +04:00
// only if file is on 'files' folder fix file size and sharing
if (isset($path_split) && $path_split[2] === 'files' && $util->fixFileSize($path)) {
2013-05-20 03:24:36 +04:00
// get sharing app state
$sharingEnabled = \OCP\Share::isEnabled();
2013-05-20 03:24:36 +04:00
// get users
2013-05-27 19:26:58 +04:00
$usersSharing = $util->getSharingUsersArray($sharingEnabled, $path_f);
2013-05-20 03:24:36 +04:00
// update sharing-keys
2013-05-27 19:26:58 +04:00
$util->setSharedFileKeyfiles($session, $usersSharing, $path_f);
2013-05-20 03:24:36 +04:00
}
2013-05-20 03:24:36 +04:00
\OC_FileProxy::$enabled = $proxyStatus;
}
}